code-7e4058dfb29b/test/.cvsignore 0000644 0000000 0000000 00000000046 07763742201 014730 0 ustar 0000000 0000000 *.pyc
*.pyo
localconfig.py
db
*.cover
code-7e4058dfb29b/test/README.txt 0000644 0000000 0000000 00000001371 07763742201 014430 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-7e4058dfb29b/test/__init__.py 0000644 0000000 0000000 00000000032 07763742201 015034 0 ustar 0000000 0000000 # make this dir a package
code-7e4058dfb29b/test/benchmark.py 0000644 0000000 0000000 00000012024 07763742201 015233 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-7e4058dfb29b/test/db_test_base.py 0000644 0000000 0000000 00000121113 07763742201 015717 0 ustar 0000000 0000000 #
# Copyright (c) 2001 Bizar Software Pty Ltd (http://www.bizarsoftware.com.au/)
# This module is free software, and you may redistribute it and/or modify
# under the same terms as Python, so long as this copyright message and
# disclaimer are retained in their original form.
#
# IN NO EVENT SHALL BIZAR SOFTWARE PTY LTD BE LIABLE TO ANY PARTY FOR
# DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING
# OUT OF THE USE OF THIS CODE, EVEN IF THE AUTHOR HAS BEEN ADVISED OF THE
# POSSIBILITY OF SUCH DAMAGE.
#
# BIZAR SOFTWARE PTY LTD SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING,
# BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
# FOR A PARTICULAR PURPOSE. THE CODE PROVIDED HEREUNDER IS ON AN "AS IS"
# BASIS, AND THERE IS NO OBLIGATION WHATSOEVER TO PROVIDE MAINTENANCE,
# SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
#
# $Id: db_test_base.py,v 1.10 2003-11-16 22:56:46 jlgijsbers Exp $
import unittest, os, shutil, errno, imp, sys, time, pprint
from roundup.hyperdb import String, Password, Link, Multilink, Date, \
Interval, DatabaseError, Boolean, Number, Node
from roundup import date, password
from roundup import init
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):
if hasattr(self, 'db'):
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'
class DBTest(MyTestCase):
def setUp(self):
# remove previous test, ignore errors
if os.path.exists(config.DATABASE):
shutil.rmtree(config.DATABASE)
os.makedirs(config.DATABASE + '/files')
self.db = self.module.Database(config, 'admin')
setupSchema(self.db, 1, self.module)
#
# 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')
def testCacheCreateSet(self):
self.db.issue.create(title="spam", status='1')
a = self.db.issue.get('1', 'title')
self.assertEqual(a, 'spam')
self.db.issue.set('1', title='ham')
b = self.db.issue.get('1', 'title')
self.assertEqual(b, 'ham')
def testSerialisation(self):
nid = self.db.issue.create(title="spam", status='1',
deadline=date.Date(), foo=date.Interval('-1d'))
self.db.commit()
assert isinstance(self.db.issue.get(nid, 'deadline'), date.Date)
assert isinstance(self.db.issue.get(nid, 'foo'), date.Interval)
uid = self.db.user.create(username="fozzy",
password=password.Password('t. bear'))
self.db.commit()
assert isinstance(self.db.user.get(uid, 'password'), password.Password)
def testTransactions(self):
# remember the number of items we started
num_issues = len(self.db.issue.list())
num_files = self.db.numfiles()
self.db.issue.create(title="don't commit me!", status='1')
self.assertNotEqual(num_issues, len(self.db.issue.list()))
self.db.rollback()
self.assertEqual(num_issues, len(self.db.issue.list()))
self.db.issue.create(title="please commit me!", status='1')
self.assertNotEqual(num_issues, len(self.db.issue.list()))
self.db.commit()
self.assertNotEqual(num_issues, len(self.db.issue.list()))
self.db.rollback()
self.assertNotEqual(num_issues, len(self.db.issue.list()))
self.db.file.create(name="test", type="text/plain", content="hi")
self.db.rollback()
self.assertEqual(num_files, self.db.numfiles())
for i in range(10):
self.db.file.create(name="test", type="text/plain",
content="hi %d"%(i))
self.db.commit()
num_files2 = self.db.numfiles()
self.assertNotEqual(num_files, num_files2)
self.db.file.create(name="test", type="text/plain", content="hi")
self.db.rollback()
self.assertNotEqual(num_files, self.db.numfiles())
self.assertEqual(num_files2, self.db.numfiles())
# rollback / cache interaction
name1 = self.db.user.get('1', 'username')
self.db.user.set('1', username = name1+name1)
# get the prop so the info's forced into the cache (if there is one)
self.db.user.get('1', 'username')
self.db.rollback()
name2 = self.db.user.get('1', 'username')
self.assertEqual(name1, name2)
def testDestroyNoJournalling(self):
self.innerTestDestroy(klass=self.db.session)
def testDestroyJournalling(self):
self.innerTestDestroy(klass=self.db.issue)
def innerTestDestroy(self, klass):
newid = klass.create(title='Mr Friendly')
n = len(klass.list())
self.assertEqual(klass.get(newid, 'title'), 'Mr Friendly')
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)
got = self.db.issue.find(status={'1':1})
got.sort()
self.assertEqual(got, ids)
# none
self.assertEqual(self.db.issue.find(status='4'), [])
self.assertEqual(self.db.issue.find(status={'4':1}), [])
# should match first and third
got = self.db.issue.find(assignedto=None)
got.sort()
self.assertEqual(got, ids)
got = self.db.issue.find(assignedto={None:1})
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)
got = self.db.issue.find(status={'1':1}, nosy={'2':1})
got.sort()
self.assertEqual(got, ids)
# none
self.assertEqual(self.db.issue.find(status='4', nosy='3'), [])
self.assertEqual(self.db.issue.find(status={'4':1}, nosy={'3':1}), [])
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 testFilteringRetired(self):
ae, filt = self.filteringSetup()
self.db.issue.retire('2')
ae(filt(None, {'status': '1'}, ('+','id'), (None,None)), ['3'])
def testFilteringMultilink(self):
ae, filt = self.filteringSetup()
ae(filt(None, {'nosy': '2'}, ('+','id'), (None,None)), ['3'])
ae(filt(None, {'nosy': '-1'}, ('+','id'), (None,None)), ['1', '2'])
def testFilteringMany(self):
ae, filt = self.filteringSetup()
ae(filt(None, {'nosy': '2', 'status': '1'}, ('+','id'), (None,None)),
['3'])
def testFilteringRange(self):
ae, filt = self.filteringSetup()
# Date ranges
ae(filt(None, {'deadline': 'from 2003-02-10 to 2003-02-23'}), ['2','3'])
ae(filt(None, {'deadline': '2003-02-10; 2003-02-23'}), ['2','3'])
ae(filt(None, {'deadline': '; 2003-02-16'}), ['1'])
# Lets assume people won't invent a time machine, otherwise this test
# may fail :)
ae(filt(None, {'deadline': 'from 2003-02-16'}), ['2', '3', '4'])
ae(filt(None, {'deadline': '2003-02-16;'}), ['2', '3', '4'])
# year and month granularity
ae(filt(None, {'deadline': '2002'}), [])
ae(filt(None, {'deadline': '2003'}), ['1', '2', '3'])
ae(filt(None, {'deadline': '2004'}), ['4'])
ae(filt(None, {'deadline': '2003-02'}), ['2', '3'])
ae(filt(None, {'deadline': '2003-03'}), [])
ae(filt(None, {'deadline': '2003-02-16'}), ['2'])
ae(filt(None, {'deadline': '2003-02-17'}), [])
# Interval ranges
ae(filt(None, {'foo': 'from 0:50 to 2:00'}), ['1'])
ae(filt(None, {'foo': 'from 0:50 to 1d 2:00'}), ['1', '2'])
ae(filt(None, {'foo': 'from 5:50'}), ['2'])
ae(filt(None, {'foo': 'to 0:05'}), [])
def testFilteringIntervalSort(self):
ae, filt = self.filteringSetup()
# ascending should sort None, 1:10, 1d
ae(filt(None, {}, ('+','foo'), (None,None)), ['3', '4', '1', '2'])
# descending should sort 1d, 1:10, None
ae(filt(None, {}, ('-','foo'), (None,None)), ['2', '1', '4', '3'])
# XXX add sorting tests for other types
# XXX test auditors and reactors
def testImportExport(self):
# use the filtering setup to create a bunch of items
ae, filt = self.filteringSetup()
self.db.user.retire('3')
self.db.issue.retire('2')
# grab snapshot of the current database
orig = {}
for cn,klass in self.db.classes.items():
cl = orig[cn] = {}
for id in klass.list():
it = cl[id] = {}
for name in klass.getprops().keys():
it[name] = klass.get(id, name)
# grab the export
export = {}
for cn,klass in self.db.classes.items():
names = klass.getprops().keys()
cl = export[cn] = [names+['is retired']]
for id in klass.getnodeids():
cl.append(klass.export_list(names, id))
# shut down this db and nuke it
self.db.close()
self.nuke_database()
# open a new, empty database
os.makedirs(config.DATABASE + '/files')
self.db = self.module.Database(config, 'admin')
setupSchema(self.db, 0, self.module)
# import
for cn, items in export.items():
klass = self.db.classes[cn]
names = items[0]
for itemprops in items[1:]:
klass.import_list(names, itemprops)
# grab snapshot of the current database
for cn, items in orig.items():
klass = self.db.classes[cn]
# ensure retired items are retired :)
l = items.keys(); l.sort()
m = klass.list(); m.sort()
ae(l, m)
for id, props in items.items():
for name, value in props.items():
ae(klass.get(id, name), value)
# make sure the retired items are actually imported
ae(self.db.user.get('3', 'username'), 'blop')
ae(self.db.issue.get('2', 'title'), 'issue two')
def testSafeGet(self):
# existent nodeid, existent property
self.assertEqual(self.db.user.safeget('1', 'username'), 'admin')
# nonexistent nodeid, existent property
self.assertEqual(self.db.user.safeget('999', 'username'), None)
# different default
self.assertEqual(self.db.issue.safeget('999', 'nosy', []), [])
class ROTest(MyTestCase):
def setUp(self):
# remove previous test, ignore errors
if os.path.exists(config.DATABASE):
shutil.rmtree(config.DATABASE)
os.makedirs(config.DATABASE + '/files')
self.db = self.module.Database(config, 'admin')
setupSchema(self.db, 1, self.module)
self.db.close()
self.db = self.module.Database(config)
setupSchema(self.db, 0, self.module)
def testExceptions(self):
# this tests the exceptions that should be raised
ar = self.assertRaises
# this tests the exceptions that should be raised
ar(DatabaseError, self.db.status.create, name="foo")
ar(DatabaseError, self.db.status.set, '1', name="foo")
ar(DatabaseError, self.db.status.retire, '1')
class SchemaTest(MyTestCase):
def setUp(self):
# remove previous test, ignore errors
if os.path.exists(config.DATABASE):
shutil.rmtree(config.DATABASE)
os.makedirs(config.DATABASE + '/files')
def init_a(self):
self.db = self.module.Database(config, 'admin')
a = self.module.Class(self.db, "a", name=String())
a.setkey("name")
self.db.post_init()
def init_ab(self):
self.db = self.module.Database(config, 'admin')
a = self.module.Class(self.db, "a", name=String())
a.setkey("name")
b = self.module.Class(self.db, "b", name=String())
b.setkey("name")
self.db.post_init()
def test_addNewClass(self):
self.init_a()
aid = self.db.a.create(name='apple')
self.db.commit(); self.db.close()
# add a new class to the schema and check creation of new items
# (and existence of old ones)
self.init_ab()
bid = self.db.b.create(name='bear')
self.assertEqual(self.db.a.get(aid, 'name'), 'apple')
self.db.commit()
self.db.close()
# now check we can recall the added class' items
self.init_ab()
self.assertEqual(self.db.a.get(aid, 'name'), 'apple')
self.assertEqual(self.db.a.lookup('apple'), aid)
self.assertEqual(self.db.b.get(bid, 'name'), 'bear')
self.assertEqual(self.db.b.lookup('bear'), bid)
# confirm journal's ok
self.db.getjournal('a', aid)
self.db.getjournal('b', bid)
def init_amod(self):
self.db = self.module.Database(config, 'admin')
a = self.module.Class(self.db, "a", name=String(), fooz=String())
a.setkey("name")
b = self.module.Class(self.db, "b", name=String())
b.setkey("name")
self.db.post_init()
def test_modifyClass(self):
self.init_ab()
# add item to user and issue class
aid = self.db.a.create(name='apple')
bid = self.db.b.create(name='bear')
self.db.commit(); self.db.close()
# modify "a" schema
self.init_amod()
self.assertEqual(self.db.a.get(aid, 'name'), 'apple')
self.assertEqual(self.db.a.get(aid, 'fooz'), None)
self.assertEqual(self.db.b.get(aid, 'name'), 'bear')
aid2 = self.db.a.create(name='aardvark', fooz='booz')
self.db.commit(); self.db.close()
# test
self.init_amod()
self.assertEqual(self.db.a.get(aid, 'name'), 'apple')
self.assertEqual(self.db.a.get(aid, 'fooz'), None)
self.assertEqual(self.db.b.get(aid, 'name'), 'bear')
self.assertEqual(self.db.a.get(aid2, 'name'), 'aardvark')
self.assertEqual(self.db.a.get(aid2, 'fooz'), 'booz')
# confirm journal's ok
self.db.getjournal('a', aid)
self.db.getjournal('a', aid2)
def init_amodkey(self):
self.db = self.module.Database(config, 'admin')
a = self.module.Class(self.db, "a", name=String(), fooz=String())
a.setkey("fooz")
b = self.module.Class(self.db, "b", name=String())
b.setkey("name")
self.db.post_init()
def test_changeClassKey(self):
self.init_amod()
aid = self.db.a.create(name='apple')
self.assertEqual(self.db.a.lookup('apple'), aid)
self.db.commit(); self.db.close()
# change the key to fooz on a
self.init_amodkey()
self.assertEqual(self.db.a.get(aid, 'name'), 'apple')
self.assertEqual(self.db.a.get(aid, 'fooz'), None)
self.assertRaises(KeyError, self.db.a.lookup, 'apple')
aid2 = self.db.a.create(name='aardvark', fooz='booz')
self.db.commit(); self.db.close()
# check
self.init_amodkey()
self.assertEqual(self.db.a.lookup('booz'), aid2)
# confirm journal's ok
self.db.getjournal('a', aid)
def init_ml(self):
self.db = self.module.Database(config, 'admin')
a = self.module.Class(self.db, "a", name=String())
a.setkey('name')
b = self.module.Class(self.db, "b", name=String(),
fooz=Multilink('a'))
b.setkey("name")
self.db.post_init()
def test_makeNewMultilink(self):
self.init_a()
aid = self.db.a.create(name='apple')
self.assertEqual(self.db.a.lookup('apple'), aid)
self.db.commit(); self.db.close()
# add a multilink prop
self.init_ml()
bid = self.db.b.create(name='bear', fooz=[aid])
self.assertEqual(self.db.b.find(fooz=aid), [bid])
self.assertEqual(self.db.a.lookup('apple'), aid)
self.db.commit(); self.db.close()
# check
self.init_ml()
self.assertEqual(self.db.b.find(fooz=aid), [bid])
self.assertEqual(self.db.a.lookup('apple'), aid)
self.assertEqual(self.db.b.lookup('bear'), bid)
# confirm journal's ok
self.db.getjournal('a', aid)
self.db.getjournal('b', bid)
def test_removeMultilink(self):
# add a multilink prop
self.init_ml()
aid = self.db.a.create(name='apple')
bid = self.db.b.create(name='bear', fooz=[aid])
self.assertEqual(self.db.b.find(fooz=aid), [bid])
self.assertEqual(self.db.a.lookup('apple'), aid)
self.assertEqual(self.db.b.lookup('bear'), bid)
self.db.commit(); self.db.close()
# remove the multilink
self.init_ab()
self.assertEqual(self.db.a.lookup('apple'), aid)
self.assertEqual(self.db.b.lookup('bear'), bid)
# confirm journal's ok
self.db.getjournal('a', aid)
self.db.getjournal('b', bid)
def test_removeClass(self):
self.init_ml()
aid = self.db.a.create(name='apple')
bid = self.db.b.create(name='bear', fooz=[aid])
self.db.commit(); self.db.close()
# drop the b class
self.init_a()
self.assertEqual(self.db.a.get(aid, 'name'), 'apple')
self.assertEqual(self.db.a.lookup('apple'), aid)
self.db.commit(); self.db.close()
# now check we can recall the added class' items
self.init_a()
self.assertEqual(self.db.a.get(aid, 'name'), 'apple')
self.assertEqual(self.db.a.lookup('apple'), aid)
# confirm journal's ok
self.db.getjournal('a', aid)
class ClassicInitTest(unittest.TestCase):
count = 0
db = None
extra_config = ''
def setUp(self):
ClassicInitTest.count = ClassicInitTest.count + 1
self.dirname = '_test_init_%s'%self.count
try:
shutil.rmtree(self.dirname)
except OSError, error:
if error.errno not in (errno.ENOENT, errno.ESRCH): raise
def testCreation(self):
ae = self.assertEqual
# create the instance
init.install(self.dirname, 'templates/classic')
init.write_select_db(self.dirname, self.backend)
if self.extra_config:
f = open(os.path.join(self.dirname, 'config.py'), 'a')
try:
f.write(self.extra_config)
finally:
f.close()
init.initialise(self.dirname, 'sekrit')
# check we can load the package
instance = imp.load_package(self.dirname, self.dirname)
# and open the database
db = self.db = instance.open()
# check the basics of the schema and initial data set
l = db.priority.list()
ae(l, ['1', '2', '3', '4', '5'])
l = db.status.list()
ae(l, ['1', '2', '3', '4', '5', '6', '7', '8'])
l = db.keyword.list()
ae(l, [])
l = db.user.list()
ae(l, ['1', '2'])
l = db.msg.list()
ae(l, [])
l = db.file.list()
ae(l, [])
l = db.issue.list()
ae(l, [])
def tearDown(self):
if self.db is not None:
self.db.close()
try:
shutil.rmtree(self.dirname)
except OSError, error:
if error.errno not in (errno.ENOENT, errno.ESRCH): raise
code-7e4058dfb29b/test/test_anydbm.py 0000644 0000000 0000000 00000003560 07763742201 015617 0 ustar 0000000 0000000 #
# Copyright (c) 2001 Bizar Software Pty Ltd (http://www.bizarsoftware.com.au/)
# This module is free software, and you may redistribute it and/or modify
# under the same terms as Python, so long as this copyright message and
# disclaimer are retained in their original form.
#
# IN NO EVENT SHALL BIZAR SOFTWARE PTY LTD BE LIABLE TO ANY PARTY FOR
# DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING
# OUT OF THE USE OF THIS CODE, EVEN IF THE AUTHOR HAS BEEN ADVISED OF THE
# POSSIBILITY OF SUCH DAMAGE.
#
# BIZAR SOFTWARE PTY LTD SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING,
# BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
# FOR A PARTICULAR PURPOSE. THE CODE PROVIDED HEREUNDER IS ON AN "AS IS"
# BASIS, AND THERE IS NO OBLIGATION WHATSOEVER TO PROVIDE MAINTENANCE,
# SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
#
# $Id: test_anydbm.py,v 1.2 2003-11-14 00:11:19 richard Exp $
import unittest, os, shutil, time
from db_test_base import DBTest, ROTest, SchemaTest, ClassicInitTest, config
class anydbmOpener:
from roundup.backends import anydbm as module
def nuke_database(self):
shutil.rmtree(config.DATABASE)
class anydbmDBTest(anydbmOpener, DBTest):
pass
class anydbmROTest(anydbmOpener, ROTest):
pass
class anydbmSchemaTest(anydbmOpener, SchemaTest):
pass
class anydbmClassicInitTest(ClassicInitTest):
backend = 'anydbm'
def test_suite():
suite = unittest.TestSuite()
print 'Including anydbm tests'
suite.addTest(unittest.makeSuite(anydbmDBTest))
suite.addTest(unittest.makeSuite(anydbmROTest))
suite.addTest(unittest.makeSuite(anydbmSchemaTest))
suite.addTest(unittest.makeSuite(anydbmClassicInitTest))
return suite
if __name__ == '__main__':
runner = unittest.TextTestRunner()
unittest.main(testRunner=runner)
# vim: set filetype=python ts=4 sw=4 et si
code-7e4058dfb29b/test/test_bsddb.py 0000644 0000000 0000000 00000003731 07763742201 015423 0 ustar 0000000 0000000 #
# Copyright (c) 2001 Bizar Software Pty Ltd (http://www.bizarsoftware.com.au/)
# This module is free software, and you may redistribute it and/or modify
# under the same terms as Python, so long as this copyright message and
# disclaimer are retained in their original form.
#
# IN NO EVENT SHALL BIZAR SOFTWARE PTY LTD BE LIABLE TO ANY PARTY FOR
# DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING
# OUT OF THE USE OF THIS CODE, EVEN IF THE AUTHOR HAS BEEN ADVISED OF THE
# POSSIBILITY OF SUCH DAMAGE.
#
# BIZAR SOFTWARE PTY LTD SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING,
# BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
# FOR A PARTICULAR PURPOSE. THE CODE PROVIDED HEREUNDER IS ON AN "AS IS"
# BASIS, AND THERE IS NO OBLIGATION WHATSOEVER TO PROVIDE MAINTENANCE,
# SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
#
# $Id: test_bsddb.py,v 1.2 2003-11-14 00:11:19 richard Exp $
import unittest, os, shutil, time
from db_test_base import DBTest, ROTest, SchemaTest, ClassicInitTest, config
from roundup import backends
class bsddbOpener:
if hasattr(backends, 'bsddb'):
from roundup.backends import bsddb as module
def nuke_database(self):
shutil.rmtree(config.DATABASE)
class bsddbDBTest(bsddbOpener, DBTest):
pass
class bsddbROTest(bsddbOpener, ROTest):
pass
class bsddbSchemaTest(bsddbOpener, SchemaTest):
pass
class bsddbClassicInitTest(ClassicInitTest):
backend = 'bsddb'
def test_suite():
suite = unittest.TestSuite()
if not hasattr(backends, 'bsddb'):
print 'Skipping bsddb tests'
return suite
print 'Including bsddb tests'
suite.addTest(unittest.makeSuite(bsddbDBTest))
suite.addTest(unittest.makeSuite(bsddbROTest))
suite.addTest(unittest.makeSuite(bsddbSchemaTest))
suite.addTest(unittest.makeSuite(bsddbClassicInitTest))
return suite
if __name__ == '__main__':
runner = unittest.TextTestRunner()
unittest.main(testRunner=runner)
code-7e4058dfb29b/test/test_bsddb3.py 0000644 0000000 0000000 00000003754 07763742201 015513 0 ustar 0000000 0000000 #
# Copyright (c) 2001 Bizar Software Pty Ltd (http://www.bizarsoftware.com.au/)
# This module is free software, and you may redistribute it and/or modify
# under the same terms as Python, so long as this copyright message and
# disclaimer are retained in their original form.
#
# IN NO EVENT SHALL BIZAR SOFTWARE PTY LTD BE LIABLE TO ANY PARTY FOR
# DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING
# OUT OF THE USE OF THIS CODE, EVEN IF THE AUTHOR HAS BEEN ADVISED OF THE
# POSSIBILITY OF SUCH DAMAGE.
#
# BIZAR SOFTWARE PTY LTD SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING,
# BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
# FOR A PARTICULAR PURPOSE. THE CODE PROVIDED HEREUNDER IS ON AN "AS IS"
# BASIS, AND THERE IS NO OBLIGATION WHATSOEVER TO PROVIDE MAINTENANCE,
# SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
#
# $Id: test_bsddb3.py,v 1.2 2003-11-14 00:11:19 richard Exp $
import unittest, os, shutil, time
from db_test_base import DBTest, ROTest, SchemaTest, ClassicInitTest, config
from roundup import backends
class bsddb3Opener:
if hasattr(backends, 'bsddb3'):
from roundup.backends import bsddb3 as module
def nuke_database(self):
shutil.rmtree(config.DATABASE)
class bsddb3DBTest(bsddb3Opener, DBTest):
pass
class bsddb3ROTest(bsddb3Opener, ROTest):
pass
class bsddb3SchemaTest(bsddb3Opener, SchemaTest):
pass
class bsddb3ClassicInitTest(ClassicInitTest):
backend = 'bsddb3'
def test_suite():
suite = unittest.TestSuite()
if not hasattr(backends, 'bsddb3'):
print 'Skipping bsddb3 tests'
return suite
print 'Including bsddb3 tests'
suite.addTest(unittest.makeSuite(bsddb3DBTest))
suite.addTest(unittest.makeSuite(bsddb3ROTest))
suite.addTest(unittest.makeSuite(bsddb3SchemaTest))
suite.addTest(unittest.makeSuite(bsddb3ClassicInitTest))
return suite
if __name__ == '__main__':
runner = unittest.TextTestRunner()
unittest.main(testRunner=runner)
code-7e4058dfb29b/test/test_cgi.py 0000644 0000000 0000000 00000054413 07763742201 015112 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.21 2003-10-25 22:53:26 richard Exp $
import unittest, os, shutil, errno, sys, difflib, cgi, re
from roundup.cgi import client
from roundup.cgi.client import FormError
from roundup import init, instance, password, hyperdb, date
NEEDS_INSTANCE = 1
class FileUpload:
def __init__(self, content, filename):
self.content = content
self.filename = filename
def makeForm(args):
form = cgi.FieldStorage()
for k,v in args.items():
if type(v) is type([]):
[form.list.append(cgi.MiniFieldStorage(k, x)) for x in v]
elif isinstance(v, FileUpload):
x = cgi.MiniFieldStorage(k, v.content)
x.filename = v.filename
form.list.append(x)
else:
form.list.append(cgi.MiniFieldStorage(k, v))
return form
class config:
TRACKER_NAME = 'testing testing'
TRACKER_WEB = 'http://testing.testing/'
cm = client.clean_message
class MessageTestCase(unittest.TestCase):
def testCleanMessageOK(self):
self.assertEqual(cm('
x
'), '
x
')
self.assertEqual(cm('x'), 'x')
self.assertEqual(cm('x'), 'x')
self.assertEqual(cm('x'),
'x')
self.assertEqual(cm('
x
'), '
x
')
self.assertEqual(cm('x'), 'x')
self.assertEqual(cm('x'), 'x')
self.assertEqual(cm('x'),
'x')
def testCleanMessageBAD(self):
self.assertEqual(cm(''),
'<script>x</script>')
self.assertEqual(cm(''),
'<iframe>x</iframe>')
class FormTestCase(unittest.TestCase):
def setUp(self):
self.dirname = '_test_cgi_form'
try:
shutil.rmtree(self.dirname)
except OSError, error:
if error.errno not in (errno.ENOENT, errno.ESRCH): raise
# create the instance
init.install(self.dirname, 'templates/classic')
init.write_select_db(self.dirname, 'anydbm')
init.initialise(self.dirname, 'sekrit')
# check we can load the package
self.instance = instance.open(self.dirname)
# and open the database
self.db = self.instance.open('admin')
self.db.user.create(username='Chef', address='chef@bork.bork.bork',
realname='Bork, Chef', roles='User')
self.db.user.create(username='mary', address='mary@test',
roles='User', realname='Contrary, Mary')
test = self.instance.dbinit.Class(self.db, "test",
string=hyperdb.String(), number=hyperdb.Number(),
boolean=hyperdb.Boolean(), link=hyperdb.Link('test'),
multilink=hyperdb.Multilink('test'), date=hyperdb.Date(),
interval=hyperdb.Interval())
# compile the labels re
classes = '|'.join(self.db.classes.keys())
self.FV_SPECIAL = re.compile(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(FormError, self.parseForm, {':required': 'string'})
self.assertRaises(FormError, self.parseForm,
{':required': 'title,status', 'status':'1'}, 'issue')
self.assertRaises(FormError, self.parseForm,
{':required': ['title','status'], 'status':'1'}, 'issue')
self.assertRaises(FormError, self.parseForm,
{':required': 'status', 'status':''}, 'issue')
self.assertRaises(FormError, self.parseForm,
{':required': 'nosy', 'nosy':''}, 'issue')
#
# Nonexistant edit
#
def testEditNonexistant(self):
self.assertRaises(FormError, self.parseForm, {'boolean': ''},
'test', '1')
#
# String
#
def testEmptyString(self):
self.assertEqual(self.parseForm({'string': ''}),
({('test', None): {}}, []))
self.assertEqual(self.parseForm({'string': ' '}),
({('test', None): {}}, []))
self.assertRaises(FormError, self.parseForm, {'string': ['', '']})
def testSetString(self):
self.assertEqual(self.parseForm({'string': 'foo'}),
({('test', None): {'string': 'foo'}}, []))
self.assertEqual(self.parseForm({'string': 'a\r\nb\r\n'}),
({('test', None): {'string': 'a\nb'}}, []))
nodeid = self.db.issue.create(title='foo')
self.assertEqual(self.parseForm({'title': 'foo'}, 'issue', nodeid),
({('issue', nodeid): {}}, []))
def testEmptyStringSet(self):
nodeid = self.db.issue.create(title='foo')
self.assertEqual(self.parseForm({'title': ''}, 'issue', nodeid),
({('issue', nodeid): {'title': None}}, []))
nodeid = self.db.issue.create(title='foo')
self.assertEqual(self.parseForm({'title': ' '}, 'issue', nodeid),
({('issue', nodeid): {'title': None}}, []))
def testFileUpload(self):
file = FileUpload('foo', 'foo.txt')
self.assertEqual(self.parseForm({'content': file}, 'file'),
({('file', None): {'content': 'foo', 'name': 'foo.txt',
'type': 'text/plain'}}, []))
def testEditFileClassAttributes(self):
self.assertEqual(self.parseForm({'name': 'foo.txt',
'type': 'application/octet-stream'},
'file'),
({('file', None): {'name': 'foo.txt',
'type': 'application/octet-stream'}},[]))
#
# Link
#
def testEmptyLink(self):
self.assertEqual(self.parseForm({'link': ''}),
({('test', None): {}}, []))
self.assertEqual(self.parseForm({'link': ' '}),
({('test', None): {}}, []))
self.assertRaises(FormError, self.parseForm, {'link': ['', '']})
self.assertEqual(self.parseForm({'link': '-1'}),
({('test', None): {}}, []))
def testSetLink(self):
self.assertEqual(self.parseForm({'status': 'unread'}, 'issue'),
({('issue', None): {'status': '1'}}, []))
self.assertEqual(self.parseForm({'status': '1'}, 'issue'),
({('issue', None): {'status': '1'}}, []))
nodeid = self.db.issue.create(status='unread')
self.assertEqual(self.parseForm({'status': 'unread'}, 'issue', nodeid),
({('issue', nodeid): {}}, []))
def testUnsetLink(self):
nodeid = self.db.issue.create(status='unread')
self.assertEqual(self.parseForm({'status': '-1'}, 'issue', nodeid),
({('issue', nodeid): {'status': None}}, []))
def testInvalidLinkValue(self):
# XXX This is not the current behaviour - should we enforce this?
# self.assertRaises(IndexError, self.parseForm,
# {'status': '4'}))
self.assertRaises(FormError, self.parseForm, {'link': 'frozzle'})
self.assertRaises(FormError, self.parseForm, {'status': 'frozzle'},
'issue')
#
# Multilink
#
def testEmptyMultilink(self):
self.assertEqual(self.parseForm({'nosy': ''}),
({('test', None): {}}, []))
self.assertEqual(self.parseForm({'nosy': ' '}),
({('test', None): {}}, []))
def testSetMultilink(self):
self.assertEqual(self.parseForm({'nosy': '1'}, 'issue'),
({('issue', None): {'nosy': ['1']}}, []))
self.assertEqual(self.parseForm({'nosy': 'admin'}, 'issue'),
({('issue', None): {'nosy': ['1']}}, []))
self.assertEqual(self.parseForm({'nosy': ['1','2']}, 'issue'),
({('issue', None): {'nosy': ['1','2']}}, []))
self.assertEqual(self.parseForm({'nosy': '1,2'}, 'issue'),
({('issue', None): {'nosy': ['1','2']}}, []))
self.assertEqual(self.parseForm({'nosy': 'admin,2'}, 'issue'),
({('issue', None): {'nosy': ['1','2']}}, []))
def testMixedMultilink(self):
form = cgi.FieldStorage()
form.list.append(cgi.MiniFieldStorage('nosy', '1,2'))
form.list.append(cgi.MiniFieldStorage('nosy', '3'))
cl = client.Client(self.instance, None, {'PATH_INFO':'/'}, form)
cl.classname = 'issue'
cl.nodeid = None
cl.db = self.db
self.assertEqual(cl.parsePropsFromForm(),
({('issue', None): {'nosy': ['1','2', '3']}}, []))
def testEmptyMultilinkSet(self):
nodeid = self.db.issue.create(nosy=['1','2'])
self.assertEqual(self.parseForm({'nosy': ''}, 'issue', nodeid),
({('issue', nodeid): {'nosy': []}}, []))
nodeid = self.db.issue.create(nosy=['1','2'])
self.assertEqual(self.parseForm({'nosy': ' '}, 'issue', nodeid),
({('issue', nodeid): {'nosy': []}}, []))
self.assertEqual(self.parseForm({'nosy': '1,2'}, 'issue', nodeid),
({('issue', nodeid): {}}, []))
def testInvalidMultilinkValue(self):
# XXX This is not the current behaviour - should we enforce this?
# self.assertRaises(IndexError, self.parseForm,
# {'nosy': '4'}))
self.assertRaises(FormError, self.parseForm, {'nosy': 'frozzle'},
'issue')
self.assertRaises(FormError, self.parseForm, {'nosy': '1,frozzle'},
'issue')
self.assertRaises(FormError, self.parseForm, {'multilink': 'frozzle'})
def testMultilinkAdd(self):
nodeid = self.db.issue.create(nosy=['1'])
# do nothing
self.assertEqual(self.parseForm({':add:nosy': ''}, 'issue', nodeid),
({('issue', nodeid): {}}, []))
# do something ;)
self.assertEqual(self.parseForm({':add:nosy': '2'}, 'issue', nodeid),
({('issue', nodeid): {'nosy': ['1','2']}}, []))
self.assertEqual(self.parseForm({':add:nosy': '2,mary'}, 'issue',
nodeid), ({('issue', nodeid): {'nosy': ['1','2','4']}}, []))
self.assertEqual(self.parseForm({':add:nosy': ['2','3']}, 'issue',
nodeid), ({('issue', nodeid): {'nosy': ['1','2','3']}}, []))
def testMultilinkAddNew(self):
self.assertEqual(self.parseForm({':add:nosy': ['2','3']}, 'issue'),
({('issue', None): {'nosy': ['2','3']}}, []))
def testMultilinkRemove(self):
nodeid = self.db.issue.create(nosy=['1','2'])
# do nothing
self.assertEqual(self.parseForm({':remove:nosy': ''}, 'issue', nodeid),
({('issue', nodeid): {}}, []))
# do something ;)
self.assertEqual(self.parseForm({':remove:nosy': '1'}, 'issue',
nodeid), ({('issue', nodeid): {'nosy': ['2']}}, []))
self.assertEqual(self.parseForm({':remove:nosy': 'admin,2'},
'issue', nodeid), ({('issue', nodeid): {'nosy': []}}, []))
self.assertEqual(self.parseForm({':remove:nosy': ['1','2']},
'issue', nodeid), ({('issue', nodeid): {'nosy': []}}, []))
# add and remove
self.assertEqual(self.parseForm({':add:nosy': ['3'],
':remove:nosy': ['1','2']},
'issue', nodeid), ({('issue', nodeid): {'nosy': ['3']}}, []))
# remove one that doesn't exist?
self.assertRaises(FormError, self.parseForm, {':remove:nosy': '4'},
'issue', nodeid)
def testMultilinkRetired(self):
self.db.user.retire('2')
self.assertEqual(self.parseForm({'nosy': ['2','3']}, 'issue'),
({('issue', None): {'nosy': ['2','3']}}, []))
nodeid = self.db.issue.create(nosy=['1','2'])
self.assertEqual(self.parseForm({':remove:nosy': '2'}, 'issue',
nodeid), ({('issue', nodeid): {'nosy': ['1']}}, []))
self.assertEqual(self.parseForm({':add:nosy': '3'}, 'issue', nodeid),
({('issue', nodeid): {'nosy': ['1','2','3']}}, []))
def testAddRemoveNonexistant(self):
self.assertRaises(FormError, self.parseForm, {':remove:foo': '2'},
'issue')
self.assertRaises(FormError, self.parseForm, {':add:foo': '2'},
'issue')
#
# Password
#
def testEmptyPassword(self):
self.assertEqual(self.parseForm({'password': ''}, 'user'),
({('user', None): {}}, []))
self.assertEqual(self.parseForm({'password': ''}, 'user'),
({('user', None): {}}, []))
self.assertRaises(FormError, self.parseForm, {'password': ['', '']},
'user')
self.assertRaises(FormError, self.parseForm, {'password': 'foo',
':confirm:password': ['', '']}, 'user')
def testSetPassword(self):
self.assertEqual(self.parseForm({'password': 'foo',
':confirm:password': 'foo'}, 'user'),
({('user', None): {'password': 'foo'}}, []))
def testSetPasswordConfirmBad(self):
self.assertRaises(FormError, self.parseForm, {'password': 'foo'},
'user')
self.assertRaises(FormError, self.parseForm, {'password': 'foo',
':confirm:password': 'bar'}, 'user')
def testEmptyPasswordNotSet(self):
nodeid = self.db.user.create(username='1',
password=password.Password('foo'))
self.assertEqual(self.parseForm({'password': ''}, 'user', nodeid),
({('user', nodeid): {}}, []))
nodeid = self.db.user.create(username='2',
password=password.Password('foo'))
self.assertEqual(self.parseForm({'password': '',
':confirm:password': ''}, 'user', nodeid),
({('user', nodeid): {}}, []))
#
# Boolean
#
def testEmptyBoolean(self):
self.assertEqual(self.parseForm({'boolean': ''}),
({('test', None): {}}, []))
self.assertEqual(self.parseForm({'boolean': ' '}),
({('test', None): {}}, []))
self.assertRaises(FormError, self.parseForm, {'boolean': ['', '']})
def testSetBoolean(self):
self.assertEqual(self.parseForm({'boolean': 'yes'}),
({('test', None): {'boolean': 1}}, []))
self.assertEqual(self.parseForm({'boolean': 'a\r\nb\r\n'}),
({('test', None): {'boolean': 0}}, []))
nodeid = self.db.test.create(boolean=1)
self.assertEqual(self.parseForm({'boolean': 'yes'}, 'test', nodeid),
({('test', nodeid): {}}, []))
nodeid = self.db.test.create(boolean=0)
self.assertEqual(self.parseForm({'boolean': 'no'}, 'test', nodeid),
({('test', nodeid): {}}, []))
def testEmptyBooleanSet(self):
nodeid = self.db.test.create(boolean=0)
self.assertEqual(self.parseForm({'boolean': ''}, 'test', nodeid),
({('test', nodeid): {'boolean': None}}, []))
nodeid = self.db.test.create(boolean=1)
self.assertEqual(self.parseForm({'boolean': ' '}, 'test', nodeid),
({('test', nodeid): {'boolean': None}}, []))
#
# Number
#
def testEmptyNumber(self):
self.assertEqual(self.parseForm({'number': ''}),
({('test', None): {}}, []))
self.assertEqual(self.parseForm({'number': ' '}),
({('test', None): {}}, []))
self.assertRaises(FormError, self.parseForm, {'number': ['', '']})
def testInvalidNumber(self):
self.assertRaises(FormError, self.parseForm, {'number': 'hi, mum!'})
def testSetNumber(self):
self.assertEqual(self.parseForm({'number': '1'}),
({('test', None): {'number': 1}}, []))
self.assertEqual(self.parseForm({'number': '\n0\n'}),
({('test', None): {'number': 0}}, []))
nodeid = self.db.test.create(number=1)
self.assertEqual(self.parseForm({'number': '1'}, 'test', nodeid),
({('test', nodeid): {}}, []))
nodeid = self.db.test.create(number=0)
self.assertEqual(self.parseForm({'number': '0'}, 'test', nodeid),
({('test', nodeid): {}}, []))
def testEmptyNumberSet(self):
nodeid = self.db.test.create(number=0)
self.assertEqual(self.parseForm({'number': ''}, 'test', nodeid),
({('test', nodeid): {'number': None}}, []))
nodeid = self.db.test.create(number=1)
self.assertEqual(self.parseForm({'number': ' '}, 'test', nodeid),
({('test', nodeid): {'number': None}}, []))
#
# Date
#
def testEmptyDate(self):
self.assertEqual(self.parseForm({'date': ''}),
({('test', None): {}}, []))
self.assertEqual(self.parseForm({'date': ' '}),
({('test', None): {}}, []))
self.assertRaises(FormError, self.parseForm, {'date': ['', '']})
def testInvalidDate(self):
self.assertRaises(FormError, self.parseForm, {'date': '12'})
def testSetDate(self):
self.assertEqual(self.parseForm({'date': '2003-01-01'}),
({('test', None): {'date': date.Date('2003-01-01')}}, []))
nodeid = self.db.test.create(date=date.Date('2003-01-01'))
self.assertEqual(self.parseForm({'date': '2003-01-01'}, 'test',
nodeid), ({('test', nodeid): {}}, []))
def testEmptyDateSet(self):
nodeid = self.db.test.create(date=date.Date('.'))
self.assertEqual(self.parseForm({'date': ''}, 'test', nodeid),
({('test', nodeid): {'date': None}}, []))
nodeid = self.db.test.create(date=date.Date('1970-01-01.00:00:00'))
self.assertEqual(self.parseForm({'date': ' '}, 'test', nodeid),
({('test', nodeid): {'date': None}}, []))
#
# Test multiple items in form
#
def testMultiple(self):
self.assertEqual(self.parseForm({'string': 'a', 'issue-1@title': 'b'}),
({('test', None): {'string': 'a'},
('issue', '-1'): {'title': 'b'}
}, []))
def testMultipleExistingContext(self):
nodeid = self.db.test.create()
self.assertEqual(self.parseForm({'string': 'a', 'issue-1@title': 'b'},
'test', nodeid),({('test', nodeid): {'string': 'a'},
('issue', '-1'): {'title': 'b'}}, []))
def testLinking(self):
self.assertEqual(self.parseForm({
'string': 'a',
'issue-1@add@nosy': '1',
'issue-2@link@superseder': 'issue-1',
}),
({('test', None): {'string': 'a'},
('issue', '-1'): {'nosy': ['1']},
('issue', '-2'): {}
},
[('issue', '-2', 'superseder', [('issue', '-1')])
]
)
)
def testLinkBadDesignator(self):
self.assertRaises(FormError, self.parseForm,
{'test-1@link@link': 'blah'})
self.assertRaises(FormError, self.parseForm,
{'test-1@link@link': 'issue'})
def testLinkNotLink(self):
self.assertRaises(FormError, self.parseForm,
{'test-1@link@boolean': 'issue-1'})
self.assertRaises(FormError, self.parseForm,
{'test-1@link@string': 'issue-1'})
def testBackwardsCompat(self):
res = self.parseForm({':note': 'spam'}, 'issue')
date = res[0][('msg', '-1')]['date']
self.assertEqual(res, ({('issue', None): {}, ('msg', '-1'):
{'content': 'spam', 'author': '1', 'date': date}},
[('issue', None, 'messages', [('msg', '-1')])]))
file = FileUpload('foo', 'foo.txt')
self.assertEqual(self.parseForm({':file': file}, 'issue'),
({('issue', None): {}, ('file', '-1'): {'content': 'foo',
'name': 'foo.txt', 'type': 'text/plain'}},
[('issue', None, 'files', [('file', '-1')])]))
def test_suite():
suite = unittest.TestSuite()
suite.addTest(unittest.makeSuite(FormTestCase))
suite.addTest(unittest.makeSuite(MessageTestCase))
return suite
if __name__ == '__main__':
runner = unittest.TextTestRunner()
unittest.main(testRunner=runner)
# vim: set filetype=python ts=4 sw=4 et si
code-7e4058dfb29b/test/test_dates.py 0000644 0000000 0000000 00000037441 07763742201 015452 0 ustar 0000000 0000000 #
# Copyright (c) 2001 Bizar Software Pty Ltd (http://www.bizarsoftware.com.au/)
# This module is free software, and you may redistribute it and/or modify
# under the same terms as Python, so long as this copyright message and
# disclaimer are retained in their original form.
#
# IN NO EVENT SHALL BIZAR SOFTWARE PTY LTD BE LIABLE TO ANY PARTY FOR
# DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING
# OUT OF THE USE OF THIS CODE, EVEN IF THE AUTHOR HAS BEEN ADVISED OF THE
# POSSIBILITY OF SUCH DAMAGE.
#
# BIZAR SOFTWARE PTY LTD SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING,
# BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
# FOR A PARTICULAR PURPOSE. THE CODE PROVIDED HEREUNDER IS ON AN "AS IS"
# BASIS, AND THERE IS NO OBLIGATION WHATSOEVER TO PROVIDE MAINTENANCE,
# SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
#
# $Id: test_dates.py,v 1.31 2003-12-04 23:06:53 richard Exp $
from __future__ import nested_scopes
import unittest, time
from roundup.date import Date, Interval, Range, fixTimeOverflow
class DateTestCase(unittest.TestCase):
def testDateInterval(self):
ae = self.assertEqual
date = Date("2000-06-26.00:34:02 + 2d")
ae(str(date), '2000-06-28.00:34:02')
date = Date("2000-02-27 + 2d")
ae(str(date), '2000-02-29.00:00:00')
date = Date("2001-02-27 + 2d")
ae(str(date), '2001-03-01.00:00:00')
def testDate(self):
ae = self.assertEqual
date = Date("2000-04-17")
ae(str(date), '2000-04-17.00:00:00')
date = Date("2000/04/17")
ae(str(date), '2000-04-17.00:00:00')
date = Date("2000-4-7")
ae(str(date), '2000-04-07.00:00:00')
date = Date("2000-4-17")
ae(str(date), '2000-04-17.00:00:00')
date = Date("01-25")
y, m, d, x, x, x, x, x, x = time.gmtime(time.time())
ae(str(date), '%s-01-25.00:00:00'%y)
date = Date("2000-04-17.03:45")
ae(str(date), '2000-04-17.03:45:00')
date = Date("2000/04/17.03:45")
ae(str(date), '2000-04-17.03:45:00')
date = Date("08-13.22:13")
ae(str(date), '%s-08-13.22:13:00'%y)
date = Date("11-07.09:32:43")
ae(str(date), '%s-11-07.09:32:43'%y)
date = Date("14:25")
ae(str(date), '%s-%02d-%02d.14:25:00'%(y, m, d))
date = Date("8:47:11")
ae(str(date), '%s-%02d-%02d.08:47:11'%(y, m, d))
ae(str(Date('2003')), '2003-01-01.00:00:00')
ae(str(Date('2004-06')), '2004-06-01.00:00:00')
def testDateError(self):
self.assertRaises(ValueError, Date, "12")
def testOffset(self):
ae = self.assertEqual
date = Date("2000-04-17", -5)
ae(str(date), '2000-04-17.05:00:00')
date = Date("01-25", -5)
y, m, d, x, x, x, x, x, x = time.gmtime(time.time())
ae(str(date), '%s-01-25.05:00:00'%y)
date = Date("2000-04-17.03:45", -5)
ae(str(date), '2000-04-17.08:45:00')
date = Date("08-13.22:13", -5)
ae(str(date), '%s-08-14.03:13:00'%y)
date = Date("11-07.09:32:43", -5)
ae(str(date), '%s-11-07.14:32:43'%y)
date = Date("14:25", -5)
ae(str(date), '%s-%02d-%02d.19:25:00'%(y, m, d))
date = Date("8:47:11", -5)
ae(str(date), '%s-%02d-%02d.13:47:11'%(y, m, d))
def testOffsetRandom(self):
ae = self.assertEqual
# XXX unsure of the usefulness of these, they're pretty random
date = Date('2000-01-01') + Interval('- 2y 2m')
ae(str(date), '1997-11-01.00:00:00')
date = Date('2000-01-01 - 2y 2m')
ae(str(date), '1997-11-01.00:00:00')
date = Date('2000-01-01') + Interval('2m')
ae(str(date), '2000-03-01.00:00:00')
date = Date('2000-01-01 + 2m')
ae(str(date), '2000-03-01.00:00:00')
date = Date('2000-01-01') + Interval('60d')
ae(str(date), '2000-03-01.00:00:00')
date = Date('2001-01-01') + Interval('60d')
ae(str(date), '2001-03-02.00:00:00')
def testOffsetAdd(self):
ae = self.assertEqual
date = Date('2000-02-28.23:59:59') + Interval('00:00:01')
ae(str(date), '2000-02-29.00:00:00')
date = Date('2001-02-28.23:59:59') + Interval('00:00:01')
ae(str(date), '2001-03-01.00:00:00')
date = Date('2000-02-28.23:58:59') + Interval('00:01:01')
ae(str(date), '2000-02-29.00:00:00')
date = Date('2001-02-28.23:58:59') + Interval('00:01:01')
ae(str(date), '2001-03-01.00:00:00')
date = Date('2000-02-28.22:58:59') + Interval('01:01:01')
ae(str(date), '2000-02-29.00:00:00')
date = Date('2001-02-28.22:58:59') + Interval('01:01:01')
ae(str(date), '2001-03-01.00:00:00')
date = Date('2000-02-28.22:58:59') + Interval('00:00:3661')
ae(str(date), '2000-02-29.00:00:00')
date = Date('2001-02-28.22:58:59') + Interval('00:00:3661')
ae(str(date), '2001-03-01.00:00:00')
def testOffsetSub(self):
ae = self.assertEqual
date = Date('2000-12-01') - Interval('- 1d')
date = Date('2000-01-01') - Interval('- 2y 2m')
ae(str(date), '2002-03-01.00:00:00')
date = Date('2000-01-01') - Interval('2m')
ae(str(date), '1999-11-01.00:00:00')
date = Date('2000-03-01') - Interval('60d')
ae(str(date), '2000-01-01.00:00:00')
date = Date('2001-03-02') - Interval('60d')
ae(str(date), '2001-01-01.00:00:00')
date = Date('2000-02-29.00:00:00') - Interval('00:00:01')
ae(str(date), '2000-02-28.23:59:59')
date = Date('2001-03-01.00:00:00') - Interval('00:00:01')
ae(str(date), '2001-02-28.23:59:59')
date = Date('2000-02-29.00:00:00') - Interval('00:01:01')
ae(str(date), '2000-02-28.23:58:59')
date = Date('2001-03-01.00:00:00') - Interval('00:01:01')
ae(str(date), '2001-02-28.23:58:59')
date = Date('2000-02-29.00:00:00') - Interval('01:01:01')
ae(str(date), '2000-02-28.22:58:59')
date = Date('2001-03-01.00:00:00') - Interval('01:01:01')
ae(str(date), '2001-02-28.22:58:59')
date = Date('2000-02-29.00:00:00') - Interval('00:00:3661')
ae(str(date), '2000-02-28.22:58:59')
date = Date('2001-03-01.00:00:00') - Interval('00:00:3661')
ae(str(date), '2001-02-28.22:58:59')
def testDateLocal(self):
ae = self.assertEqual
date = Date("02:42:20")
date = date.local(10)
y, m, d, x, x, x, x, x, x = time.gmtime(time.time())
ae(str(date), '%s-%02d-%02d.12:42:20'%(y, m, d))
def testIntervalInit(self):
ae = self.assertEqual
ae(str(Interval('3y')), '+ 3y')
ae(str(Interval('2 y 1 m')), '+ 2y 1m')
ae(str(Interval('1m 25d')), '+ 1m 25d')
ae(str(Interval('-2w 3 d ')), '- 17d')
ae(str(Interval(' - 1 d 2:50 ')), '- 1d 2:50')
ae(str(Interval(' 14:00 ')), '+ 14:00')
ae(str(Interval(' 0:04:33 ')), '+ 0:04:33')
def testIntervalInitDate(self):
ae = self.assertEqual
now = Date('.')
now.hour = now.minute = now.second = 0
then = now + Interval('2d')
ae((Interval(str(then))), Interval('- 2d'))
then = now - Interval('2d')
ae(Interval(str(then)), Interval('+ 2d'))
def testIntervalAddMonthBoundary(self):
# force the transition over a month boundary
now = Date('2003-10-30.00:00:00')
then = now + Interval('2d')
self.assertEqual(str(then), '2003-11-01.00:00:00')
now = Date('2004-02-28.00:00:00')
then = now + Interval('1d')
self.assertEqual(str(then), '2004-02-29.00:00:00')
now = Date('2003-02-28.00:00:00')
then = now + Interval('1d')
self.assertEqual(str(then), '2003-03-01.00:00:00')
now = Date('2003-01-01.00:00:00')
then = now + Interval('59d')
self.assertEqual(str(then), '2003-03-01.00:00:00')
now = Date('2004-01-01.00:00:00')
then = now + Interval('59d')
self.assertEqual(str(then), '2004-02-29.00:00:00')
def testIntervalSubtractMonthBoundary(self):
# force the transition over a month boundary
now = Date('2003-11-01.00:00:00')
then = now - Interval('2d')
self.assertEqual(str(then), '2003-10-30.00:00:00')
now = Date('2004-02-29.00:00:00')
then = now - Interval('1d')
self.assertEqual(str(then), '2004-02-28.00:00:00')
now = Date('2003-03-01.00:00:00')
then = now - Interval('1d')
self.assertEqual(str(then), '2003-02-28.00:00:00')
now = Date('2003-03-01.00:00:00')
then = now - Interval('59d')
self.assertEqual(str(then), '2003-01-01.00:00:00')
now = Date('2004-02-29.00:00:00')
then = now - Interval('59d')
self.assertEqual(str(then), '2004-01-01.00:00:00')
def testIntervalAddYearBoundary(self):
# force the transition over a year boundary
now = Date('2003-12-30.00:00:00')
then = now + Interval('2d')
self.assertEqual(str(then), '2004-01-01.00:00:00')
now = Date('2003-01-01.00:00:00')
then = now + Interval('365d')
self.assertEqual(str(then), '2004-01-01.00:00:00')
now = Date('2004-01-01.00:00:00')
then = now + Interval('366d')
self.assertEqual(str(then), '2005-01-01.00:00:00')
def testIntervalSubtractYearBoundary(self):
# force the transition over a year boundary
now = Date('2003-01-01.00:00:00')
then = now - Interval('2d')
self.assertEqual(str(then), '2002-12-30.00:00:00')
now = Date('2004-02-01.00:00:00')
then = now - Interval('365d')
self.assertEqual(str(then), '2003-02-01.00:00:00')
now = Date('2005-02-01.00:00:00')
then = now - Interval('365d')
self.assertEqual(str(then), '2004-02-02.00:00:00')
def testDateSubtract(self):
# These are thoroughly broken right now.
i = Date('2003-03-15.00:00:00') - Date('2003-03-10.00:00:00')
self.assertEqual(i, Interval('5d'))
i = Date('2003-02-01.00:00:00') - Date('2003-03-01.00:00:00')
self.assertEqual(i, Interval('-28d'))
i = Date('2003-03-01.00:00:00') - Date('2003-02-01.00:00:00')
self.assertEqual(i, Interval('28d'))
i = Date('2003-03-03.00:00:00') - Date('2003-02-01.00:00:00')
self.assertEqual(i, Interval('30d'))
i = Date('2003-03-03.00:00:00') - Date('2002-02-01.00:00:00')
self.assertEqual(i, Interval('395d'))
i = Date('2003-03-03.00:00:00') - Date('2003-04-01.00:00:00')
self.assertEqual(i, Interval('-29d'))
i = Date('2003-03-01.00:00:00') - Date('2003-02-01.00:00:00')
self.assertEqual(i, Interval('28d'))
# force the transition over a year boundary
i = Date('2003-01-01.00:00:00') - Date('2002-01-01.00:00:00')
self.assertEqual(i, Interval('365d'))
def testIntervalAdd(self):
ae = self.assertEqual
ae(str(Interval('1y') + Interval('1y')), '+ 2y')
ae(str(Interval('1y') + Interval('1m')), '+ 1y 1m')
ae(str(Interval('1y') + Interval('2:40')), '+ 1y 2:40')
ae(str(Interval('1y') + Interval('- 1y')), '')
ae(str(Interval('- 1y') + Interval('1y')), '')
ae(str(Interval('- 1y') + Interval('- 1y')), '- 2y')
ae(str(Interval('1y') + Interval('- 1m')), '+ 11m')
ae(str(Interval('1:00') + Interval('1:00')), '+ 2:00')
ae(str(Interval('0:50') + Interval('0:50')), '+ 1:40')
ae(str(Interval('1:50') + Interval('- 1:50')), '')
ae(str(Interval('- 1:50') + Interval('1:50')), '')
ae(str(Interval('- 1:50') + Interval('- 1:50')), '- 3:40')
ae(str(Interval('1:59:59') + Interval('00:00:01')), '+ 2:00')
ae(str(Interval('2:00') + Interval('- 00:00:01')), '+ 1:59:59')
def testIntervalSub(self):
ae = self.assertEqual
ae(str(Interval('1y') - Interval('- 1y')), '+ 2y')
ae(str(Interval('1y') - Interval('- 1m')), '+ 1y 1m')
ae(str(Interval('1y') - Interval('- 2:40')), '+ 1y 2:40')
ae(str(Interval('1y') - Interval('1y')), '')
ae(str(Interval('1y') - Interval('1m')), '+ 11m')
ae(str(Interval('1:00') - Interval('- 1:00')), '+ 2:00')
ae(str(Interval('0:50') - Interval('- 0:50')), '+ 1:40')
ae(str(Interval('1:50') - Interval('1:50')), '')
ae(str(Interval('1:59:59') - Interval('- 00:00:01')), '+ 2:00')
ae(str(Interval('2:00') - Interval('00:00:01')), '+ 1:59:59')
def testOverflow(self):
ae = self.assertEqual
ae(fixTimeOverflow((1,0,0,0, 0, 0, 60)), (1,0,0,0, 0, 1, 0))
ae(fixTimeOverflow((1,0,0,0, 0, 0, 100)), (1,0,0,0, 0, 1, 40))
ae(fixTimeOverflow((1,0,0,0, 0, 0, 60*60)), (1,0,0,0, 1, 0, 0))
ae(fixTimeOverflow((1,0,0,0, 0, 0, 24*60*60)), (1,0,0,1, 0, 0, 0))
ae(fixTimeOverflow((1,0,0,0, 0, 0, -1)), (-1,0,0,0, 0, 0, 1))
ae(fixTimeOverflow((1,0,0,0, 0, 0, -100)), (-1,0,0,0, 0, 1, 40))
ae(fixTimeOverflow((1,0,0,0, 0, 0, -60*60)), (-1,0,0,0, 1, 0, 0))
ae(fixTimeOverflow((1,0,0,0, 0, 0, -24*60*60)), (-1,0,0,1, 0, 0, 0))
ae(fixTimeOverflow((-1,0,0,0, 0, 0, 1)), (-1,0,0,0, 0, 0, 1))
ae(fixTimeOverflow((-1,0,0,0, 0, 0, 100)), (-1,0,0,0, 0, 1, 40))
ae(fixTimeOverflow((-1,0,0,0, 0, 0, 60*60)), (-1,0,0,0, 1, 0, 0))
ae(fixTimeOverflow((-1,0,0,0, 0, 0, 24*60*60)), (-1,0,0,1, 0, 0, 0))
def testDivision(self):
ae = self.assertEqual
ae(str(Interval('1y')/2), '+ 6m')
ae(str(Interval('1:00')/2), '+ 0:30')
ae(str(Interval('00:01')/2), '+ 0:00:30')
def testSorting(self):
ae = self.assertEqual
i1 = Interval('1y')
i2 = Interval('1d')
l = [i1, i2]; l.sort()
ae(l, [i2, i1])
l = [i2, i1]; l.sort()
ae(l, [i2, i1])
i1 = Interval('- 2d')
i2 = Interval('1d')
l = [i1, i2]; l.sort()
ae(l, [i1, i2])
i1 = Interval("1:20")
i2 = Interval("2d")
i3 = Interval("3:30")
l = [i1, i2, i3]; l.sort()
ae(l, [i1, i3, i2])
def testGranularity(self):
ae = self.assertEqual
ae(str(Date('2003-2-12', add_granularity=1)), '2003-02-12.23:59:59')
ae(str(Date('2003-1-1.23:00', add_granularity=1)), '2003-01-01.23:00:59')
ae(str(Date('2003', add_granularity=1)), '2003-12-31.23:59:59')
ae(str(Date('2003-5', add_granularity=1)), '2003-05-31.23:59:59')
ae(str(Interval('+1w', add_granularity=1)), '+ 14d')
ae(str(Interval('-2m 3w', add_granularity=1)), '- 2m 14d')
def testIntervalPretty(self):
def ae(spec, pretty):
self.assertEqual(Interval(spec).pretty(), pretty)
ae('2y', 'in 2 years')
ae('1y', 'in 1 year')
ae('2m', 'in 2 months')
ae('1m 30d', 'in 2 months')
ae('60d', 'in 2 months')
ae('59d', 'in 1 month')
ae('1m', 'in 1 month')
ae('29d', 'in 1 month')
ae('28d', 'in 4 weeks')
ae('8d', 'in 1 week')
ae('7d', 'in 7 days')
ae('1w', 'in 7 days')
ae('2d', 'in 2 days')
ae('1d', 'tomorrow')
ae('02:00:00', 'in 2 hours')
ae('01:59:00', 'in 1 3/4 hours')
ae('01:45:00', 'in 1 3/4 hours')
ae('01:30:00', 'in 1 1/2 hours')
ae('01:29:00', 'in 1 1/4 hours')
ae('01:00:00', 'in an hour')
ae('00:30:00', 'in 1/2 an hour')
ae('00:15:00', 'in 1/4 hour')
ae('00:02:00', 'in 2 minutes')
ae('00:01:00', 'in 1 minute')
ae('00:00:30', 'in a moment')
ae('-00:00:30', 'just now')
ae('-1d', 'yesterday')
ae('-1y', '1 year ago')
ae('-2y', '2 years ago')
def test_suite():
suite = unittest.TestSuite()
suite.addTest(unittest.makeSuite(DateTestCase))
return suite
if __name__ == '__main__':
runner = unittest.TextTestRunner()
unittest.main(testRunner=runner)
# vim: set filetype=python ts=4 sw=4 et si
code-7e4058dfb29b/test/test_hyperdbvals.py 0000644 0000000 0000000 00000012342 07763742201 016666 0 ustar 0000000 0000000 #
# Copyright (c) 2003 Richard Jones, richard@commonground.com.au
# This module is free software, and you may redistribute it and/or modify
# under the same terms as Python, so long as this copyright message and
# disclaimer are retained in their original form.
#
# This module is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
#
# $Id: test_hyperdbvals.py,v 1.1 2003-11-11 00:35:14 richard Exp $
import unittest, os, shutil, errno, sys, difflib, cgi, re, sha
from roundup import init, instance, password, hyperdb, date
class TestClass:
def getprops(self):
return {
'string': hyperdb.String(),
'number': hyperdb.Number(),
'boolean': hyperdb.Boolean(),
'password': hyperdb.Password(),
'date': hyperdb.Date(),
'interval': hyperdb.Interval(),
'link': hyperdb.Link('test'),
'link2': hyperdb.Link('test2'),
'multilink': hyperdb.Multilink('test'),
'multilink2': hyperdb.Multilink('test2'),
}
def getkey(self):
return 'string'
def lookup(self, value):
if value == 'valid':
return '1'
raise KeyError
def get(self, nodeid, propname):
assert propname.startswith('multilink')
assert nodeid is not None
return ['2', '3']
class TestClass2:
def properties(self):
return {
'string': hyperdb.String(),
}
def getkey(self):
return None
def labelprop(self, default_to_id=1):
return 'id'
class TestDatabase:
classes = {'test': TestClass(), 'test2': TestClass2()}
def getUserTimezone(self):
return 0
class RawToHyperdbTest(unittest.TestCase):
def _test(self, propname, value, itemid=None):
return hyperdb.rawToHyperdb(TestDatabase(), TestClass(), itemid,
propname, value)
def testString(self):
self.assertEqual(self._test('string', ' a string '), 'a string')
def testNumber(self):
self.assertEqual(self._test('number', ' 10 '), 10)
self.assertEqual(self._test('number', ' 1.5 '), 1.5)
def testBoolean(self):
for true in 'yes true on 1'.split():
self.assertEqual(self._test('boolean', ' %s '%true), 1)
for false in 'no false off 0'.split():
self.assertEqual(self._test('boolean', ' %s '%false), 0)
def testPassword(self):
self.assertEqual(self._test('password', ' a string '), 'a string')
val = self._test('password', ' a string ')
self.assert_(isinstance(val, password.Password))
val = self._test('password', '{plaintext}a string')
self.assert_(isinstance(val, password.Password))
val = self._test('password', '{crypt}a string')
self.assert_(isinstance(val, password.Password))
s = sha.sha('a string').hexdigest()
val = self._test('password', '{SHA}'+s)
self.assert_(isinstance(val, password.Password))
self.assertEqual(val, 'a string')
self.assertRaises(hyperdb.HyperdbValueError, self._test,
'password', '{fubar}a string')
def testDate(self):
val = self._test('date', ' 2003-01-01 ')
self.assert_(isinstance(val, date.Date))
val = self._test('date', ' 2003/01/01 ')
self.assert_(isinstance(val, date.Date))
val = self._test('date', ' 2003/1/1 ')
self.assert_(isinstance(val, date.Date))
val = self._test('date', ' 2003-1-1 ')
self.assert_(isinstance(val, date.Date))
self.assertRaises(hyperdb.HyperdbValueError, self._test, 'date',
'fubar')
def testInterval(self):
val = self._test('interval', ' +1d ')
self.assert_(isinstance(val, date.Interval))
self.assertRaises(hyperdb.HyperdbValueError, self._test, 'interval',
'fubar')
def testLink(self):
self.assertEqual(self._test('link', '1'), '1')
self.assertEqual(self._test('link', 'valid'), '1')
self.assertRaises(hyperdb.HyperdbValueError, self._test, 'link',
'invalid')
def testMultilink(self):
self.assertEqual(self._test('multilink', '', '1'), [])
self.assertEqual(self._test('multilink', '1', '1'), ['1'])
self.assertEqual(self._test('multilink', 'valid', '1'), ['1'])
self.assertRaises(hyperdb.HyperdbValueError, self._test, 'multilink',
'invalid', '1')
self.assertEqual(self._test('multilink', '+1', '1'), ['1', '2', '3'])
self.assertEqual(self._test('multilink', '+valid', '1'), ['1', '2',
'3'])
self.assertEqual(self._test('multilink', '+1,-2', '1'), ['1', '3'])
self.assertEqual(self._test('multilink', '+valid,-3', '1'), ['1', '2'])
self.assertEqual(self._test('multilink', '+1', None), ['1'])
self.assertEqual(self._test('multilink', '+valid', None), ['1'])
self.assertEqual(self._test('multilink', '', None), [])
def test_suite():
suite = unittest.TestSuite()
suite.addTest(unittest.makeSuite(RawToHyperdbTest))
return suite
if __name__ == '__main__':
runner = unittest.TextTestRunner()
unittest.main(testRunner=runner)
# vim: set filetype=python ts=4 sw=4 et si
code-7e4058dfb29b/test/test_indexer.py 0000644 0000000 0000000 00000004704 07763742201 016004 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.3 2003-10-25 22:53:26 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 test_suite():
suite = unittest.TestSuite()
suite.addTest(unittest.makeSuite(IndexerTest))
return suite
if __name__ == '__main__':
runner = unittest.TextTestRunner()
unittest.main(testRunner=runner)
# vim: set filetype=python ts=4 sw=4 et si
code-7e4058dfb29b/test/test_locking.py 0000644 0000000 0000000 00000004205 07763742201 015770 0 ustar 0000000 0000000 # Copyright (c) 2002 ekit.com Inc (http://www.ekit-inc.com/)
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in
# all copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
# SOFTWARE.
# $Id: test_locking.py,v 1.4 2003-10-25 22:53:26 richard Exp $
import os, unittest, tempfile
from roundup.backends.locking import acquire_lock, release_lock
class LockingTest(unittest.TestCase):
def setUp(self):
self.path = tempfile.mktemp()
open(self.path, 'w').write('hi\n')
# XXX test disabled because it simply doesn't work on many platforms
# (Solaris and Irix are known to fail, but Linux works)
def xtest_basics(self):
f = acquire_lock(self.path)
try:
acquire_lock(self.path, block=0)
except:
pass
else:
raise AssertionError, 'no exception'
release_lock(f)
f = acquire_lock(self.path)
release_lock(f)
def tearDown(self):
os.remove(self.path)
def test_suite():
suite = unittest.TestSuite()
suite.addTest(unittest.makeSuite(LockingTest))
return suite
if __name__ == '__main__':
runner = unittest.TextTestRunner()
unittest.main(testRunner=runner)
# vim: set filetype=python ts=4 sw=4 et si
code-7e4058dfb29b/test/test_mailgw.py 0000644 0000000 0000000 00000100632 07763742201 015623 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.63 2003-12-04 23:34:25 richard Exp $
import unittest, tempfile, os, shutil, errno, imp, sys, difflib, rfc822
from cStringIO import StringIO
if not os.environ.has_key('SENDMAILDEBUG'):
os.environ['SENDMAILDEBUG'] = 'mail-test.log'
SENDMAILDEBUG = os.environ['SENDMAILDEBUG']
from roundup.mailgw import MailGW, Unauthorized, uidFromAddress, \
parseContent, IgnoreLoop, IgnoreBulk
from roundup import init, instance, rfc2822
class Message(rfc822.Message):
"""String-based Message class with equivalence test."""
def __init__(self, s):
rfc822.Message.__init__(self, StringIO(s.strip()))
def __eq__(self, other):
return (self.dict == other.dict and
self.fp.read() == other.fp.read())
class DiffHelper:
def compareMessages(self, new, old):
"""Compare messages for semantic equivalence."""
new, old = Message(new), Message(old)
del new['date'], old['date']
if not new == old:
res = ['Generated message not correct (diff follows):']
for key in new.keys():
if new[key] != old[key]:
res.append(' %s: %s != %s' % (key, old[key], new[key]))
body_diff = self.compareStrings(new.fp.read(), old.fp.read())
if body_diff:
res.append('')
res.extend(body_diff)
raise AssertionError, '\n'.join(res)
def compareStrings(self, s2, s1):
'''Note the reversal of s2 and s1 - difflib.SequenceMatcher wants
the first to be the "original" but in the calls in this file,
the second arg is the original. Ho hum.
'''
l1 = s1.strip().split('\n')
l2 = s2.strip().split('\n')
if l1 == l2:
return
s = difflib.SequenceMatcher(None, l1, l2)
res = []
for value, s1s, s1e, s2s, s2e in s.get_opcodes():
if value == 'equal':
for i in range(s1s, s1e):
res.append(' %s'%l1[i])
elif value == 'delete':
for i in range(s1s, s1e):
res.append('- %s'%l1[i])
elif value == 'insert':
for i in range(s2s, s2e):
res.append('+ %s'%l2[i])
elif value == 'replace':
for i, j in zip(range(s1s, s1e), range(s2s, s2e)):
res.append('- %s'%l1[i])
res.append('+ %s'%l2[j])
return res
class MailgwTestCase(unittest.TestCase, DiffHelper):
count = 0
schema = 'classic'
def setUp(self):
MailgwTestCase.count = MailgwTestCase.count + 1
self.dirname = '_test_mailgw_%s'%self.count
try:
shutil.rmtree(self.dirname)
except OSError, error:
if error.errno not in (errno.ENOENT, errno.ESRCH): raise
# create the instance
init.install(self.dirname, 'templates/classic')
init.write_select_db(self.dirname, 'anydbm')
init.initialise(self.dirname, 'sekrit')
# check we can load the package
self.instance = instance.open(self.dirname)
# and open the database
self.db = self.instance.open('admin')
self.chef_id = self.db.user.create(username='Chef',
address='chef@bork.bork.bork', realname='Bork, Chef', roles='User')
self.richard_id = self.db.user.create(username='richard',
address='richard@test', roles='User')
self.mary_id = self.db.user.create(username='mary', address='mary@test',
roles='User', realname='Contrary, Mary')
self.john_id = self.db.user.create(username='john', address='john@test',
alternate_addresses='jondoe@test\njohn.doe@test', roles='User',
realname='John Doe')
def tearDown(self):
if os.path.exists(SENDMAILDEBUG):
os.remove(SENDMAILDEBUG)
self.db.close()
try:
shutil.rmtree(self.dirname)
except OSError, error:
if error.errno not in (errno.ENOENT, errno.ESRCH): raise
def _send_mail(self, message):
handler = self.instance.MailGW(self.instance, self.db)
handler.trapExceptions = 0
return handler.main(StringIO(message))
def _get_mail(self):
f = open(SENDMAILDEBUG)
try:
return f.read()
finally:
f.close()
def testEmptyMessage(self):
nodeid = self._send_mail('''Content-Type: text/plain;
charset="iso-8859-1"
From: Chef
To: issue_tracker@your.tracker.email.domain.example
Cc: richard@test
Message-Id:
Subject: [issue] Testing...
''')
assert not os.path.exists(SENDMAILDEBUG)
self.assertEqual(self.db.issue.get(nodeid, 'title'), 'Testing...')
def doNewIssue(self):
nodeid = self._send_mail('''Content-Type: text/plain;
charset="iso-8859-1"
From: Chef
To: issue_tracker@your.tracker.email.domain.example
Cc: richard@test
Message-Id:
Subject: [issue] Testing...
This is a test submission of a new issue.
''')
assert not os.path.exists(SENDMAILDEBUG)
l = self.db.issue.get(nodeid, 'nosy')
l.sort()
self.assertEqual(l, [self.chef_id, self.richard_id])
return nodeid
def testNewIssue(self):
self.doNewIssue()
def testNewIssueNosy(self):
self.instance.config.ADD_AUTHOR_TO_NOSY = 'yes'
nodeid = self._send_mail('''Content-Type: text/plain;
charset="iso-8859-1"
From: Chef
To: issue_tracker@your.tracker.email.domain.example
Cc: richard@test
Message-Id:
Subject: [issue] Testing...
This is a test submission of a new issue.
''')
assert not os.path.exists(SENDMAILDEBUG)
l = self.db.issue.get(nodeid, 'nosy')
l.sort()
self.assertEqual(l, [self.chef_id, self.richard_id])
def testAlternateAddress(self):
self._send_mail('''Content-Type: text/plain;
charset="iso-8859-1"
From: John Doe
To: issue_tracker@your.tracker.email.domain.example
Message-Id:
Subject: [issue] Testing...
This is a test submission of a new issue.
''')
userlist = self.db.user.list()
assert not os.path.exists(SENDMAILDEBUG)
self.assertEqual(userlist, self.db.user.list(),
"user created when it shouldn't have been")
def testNewIssueNoClass(self):
self._send_mail('''Content-Type: text/plain;
charset="iso-8859-1"
From: Chef
To: issue_tracker@your.tracker.email.domain.example
Cc: richard@test
Message-Id:
Subject: Testing...
This is a test submission of a new issue.
''')
assert not os.path.exists(SENDMAILDEBUG)
def testNewIssueAuthMsg(self):
# TODO: fix the damn config - this is apalling
self.db.config.MESSAGES_TO_AUTHOR = 'yes'
self._send_mail('''Content-Type: text/plain;
charset="iso-8859-1"
From: Chef
To: issue_tracker@your.tracker.email.domain.example
Message-Id:
Subject: [issue] Testing... [nosy=mary; assignedto=richard]
This is a test submission of a new issue.
''')
self.compareMessages(self._get_mail(),
'''FROM: roundup-admin@your.tracker.email.domain.example
TO: chef@bork.bork.bork, mary@test, richard@test
Content-Type: text/plain; charset=utf-8
Subject: [issue1] Testing...
To: chef@bork.bork.bork, mary@test, richard@test
From: "Bork, Chef"
Reply-To: Roundup issue tracker
MIME-Version: 1.0
Message-Id:
X-Roundup-Name: Roundup issue tracker
X-Roundup-Loop: hello
Content-Transfer-Encoding: quoted-printable
New submission from Bork, Chef :
This is a test submission of a new issue.
----------
assignedto: richard
messages: 1
nosy: Chef, mary, richard
status: unread
title: Testing...
_______________________________________________________________________
Roundup issue tracker
_______________________________________________________________________
''')
# BUG
# def testMultipart(self):
# '''With more than one part'''
# see MultipartEnc tests: but if there is more than one part
# we return a multipart/mixed and the boundary contains
# the ip address of the test machine.
# BUG should test some binary attamchent too.
def testSimpleFollowup(self):
self.doNewIssue()
self._send_mail('''Content-Type: text/plain;
charset="iso-8859-1"
From: mary
To: issue_tracker@your.tracker.email.domain.example
Message-Id:
In-Reply-To:
Subject: [issue1] Testing...
This is a second followup
''')
self.compareMessages(self._get_mail(),
'''FROM: roundup-admin@your.tracker.email.domain.example
TO: chef@bork.bork.bork, richard@test
Content-Type: text/plain; charset=utf-8
Subject: [issue1] Testing...
To: chef@bork.bork.bork, richard@test
From: "Contrary, Mary"
Reply-To: Roundup issue tracker
MIME-Version: 1.0
Message-Id:
In-Reply-To:
X-Roundup-Name: Roundup issue tracker
X-Roundup-Loop: hello
Content-Transfer-Encoding: quoted-printable
Contrary, Mary added the comment:
This is a second followup
----------
status: unread -> chatting
_______________________________________________________________________
Roundup issue tracker
_______________________________________________________________________
''')
def testFollowup(self):
self.doNewIssue()
self._send_mail('''Content-Type: text/plain;
charset="iso-8859-1"
From: richard
To: issue_tracker@your.tracker.email.domain.example
Message-Id:
In-Reply-To:
Subject: [issue1] Testing... [assignedto=mary; nosy=+john]
This is a followup
''')
l = self.db.issue.get('1', 'nosy')
l.sort()
self.assertEqual(l, [self.chef_id, self.richard_id, self.mary_id,
self.john_id])
self.compareMessages(self._get_mail(),
'''FROM: roundup-admin@your.tracker.email.domain.example
TO: chef@bork.bork.bork, john@test, mary@test
Content-Type: text/plain; charset=utf-8
Subject: [issue1] Testing...
To: chef@bork.bork.bork, john@test, mary@test
From: richard
Reply-To: Roundup issue tracker
MIME-Version: 1.0
Message-Id:
In-Reply-To:
X-Roundup-Name: Roundup issue tracker
X-Roundup-Loop: hello
Content-Transfer-Encoding: quoted-printable
richard added the comment:
This is a followup
----------
assignedto: -> mary
nosy: +john, mary
status: unread -> chatting
_______________________________________________________________________
Roundup issue tracker
_______________________________________________________________________
''')
def testFollowupTitleMatch(self):
self.doNewIssue()
self._send_mail('''Content-Type: text/plain;
charset="iso-8859-1"
From: richard
To: issue_tracker@your.tracker.email.domain.example
Message-Id:
In-Reply-To:
Subject: Re: Testing... [assignedto=mary; nosy=+john]
This is a followup
''')
self.compareMessages(self._get_mail(),
'''FROM: roundup-admin@your.tracker.email.domain.example
TO: chef@bork.bork.bork, john@test, mary@test
Content-Type: text/plain; charset=utf-8
Subject: [issue1] Testing...
To: chef@bork.bork.bork, john@test, mary@test
From: richard
Reply-To: Roundup issue tracker
MIME-Version: 1.0
Message-Id:
In-Reply-To:
X-Roundup-Name: Roundup issue tracker
X-Roundup-Loop: hello
Content-Transfer-Encoding: quoted-printable
richard added the comment:
This is a followup
----------
assignedto: -> mary
nosy: +john, mary
status: unread -> chatting
_______________________________________________________________________
Roundup issue tracker
_______________________________________________________________________
''')
def testFollowupNosyAuthor(self):
self.doNewIssue()
self.db.config.ADD_AUTHOR_TO_NOSY = 'yes'
self._send_mail('''Content-Type: text/plain;
charset="iso-8859-1"
From: john@test
To: issue_tracker@your.tracker.email.domain.example
Message-Id:
In-Reply-To:
Subject: [issue1] Testing...
This is a followup
''')
self.compareMessages(self._get_mail(),
'''FROM: roundup-admin@your.tracker.email.domain.example
TO: chef@bork.bork.bork, richard@test
Content-Type: text/plain; charset=utf-8
Subject: [issue1] Testing...
To: chef@bork.bork.bork, richard@test
From: John Doe
Reply-To: Roundup issue tracker
MIME-Version: 1.0
Message-Id:
In-Reply-To:
X-Roundup-Name: Roundup issue tracker
X-Roundup-Loop: hello
Content-Transfer-Encoding: quoted-printable
John Doe added the comment:
This is a followup
----------
nosy: +john
status: unread -> chatting
_______________________________________________________________________
Roundup issue tracker
_______________________________________________________________________
''')
def testFollowupNosyRecipients(self):
self.doNewIssue()
self.db.config.ADD_RECIPIENTS_TO_NOSY = 'yes'
self._send_mail('''Content-Type: text/plain;
charset="iso-8859-1"
From: richard@test
To: issue_tracker@your.tracker.email.domain.example
Cc: john@test
Message-Id:
In-Reply-To:
Subject: [issue1] Testing...
This is a followup
''')
self.compareMessages(self._get_mail(),
'''FROM: roundup-admin@your.tracker.email.domain.example
TO: chef@bork.bork.bork
Content-Type: text/plain; charset=utf-8
Subject: [issue1] Testing...
To: chef@bork.bork.bork
From: richard
Reply-To: Roundup issue tracker
MIME-Version: 1.0
Message-Id:
In-Reply-To:
X-Roundup-Name: Roundup issue tracker
X-Roundup-Loop: hello
Content-Transfer-Encoding: quoted-printable
richard added the comment:
This is a followup
----------
nosy: +john
status: unread -> chatting
_______________________________________________________________________
Roundup issue tracker
_______________________________________________________________________
''')
def testFollowupNosyAuthorAndCopy(self):
self.doNewIssue()
self.db.config.ADD_AUTHOR_TO_NOSY = 'yes'
self.db.config.MESSAGES_TO_AUTHOR = 'yes'
self._send_mail('''Content-Type: text/plain;
charset="iso-8859-1"
From: john@test
To: issue_tracker@your.tracker.email.domain.example
Message-Id:
In-Reply-To:
Subject: [issue1] Testing...
This is a followup
''')
self.compareMessages(self._get_mail(),
'''FROM: roundup-admin@your.tracker.email.domain.example
TO: chef@bork.bork.bork, john@test, richard@test
Content-Type: text/plain; charset=utf-8
Subject: [issue1] Testing...
To: chef@bork.bork.bork, john@test, richard@test
From: John Doe
Reply-To: Roundup issue tracker
MIME-Version: 1.0
Message-Id:
In-Reply-To:
X-Roundup-Name: Roundup issue tracker
X-Roundup-Loop: hello
Content-Transfer-Encoding: quoted-printable
John Doe added the comment:
This is a followup
----------
nosy: +john
status: unread -> chatting
_______________________________________________________________________
Roundup issue tracker
_______________________________________________________________________
''')
def testFollowupNoNosyAuthor(self):
self.doNewIssue()
self.instance.config.ADD_AUTHOR_TO_NOSY = 'no'
self._send_mail('''Content-Type: text/plain;
charset="iso-8859-1"
From: john@test
To: issue_tracker@your.tracker.email.domain.example
Message-Id:
In-Reply-To:
Subject: [issue1] Testing...
This is a followup
''')
self.compareMessages(self._get_mail(),
'''FROM: roundup-admin@your.tracker.email.domain.example
TO: chef@bork.bork.bork, richard@test
Content-Type: text/plain; charset=utf-8
Subject: [issue1] Testing...
To: chef@bork.bork.bork, richard@test
From: John Doe
Reply-To: Roundup issue tracker
MIME-Version: 1.0
Message-Id:
In-Reply-To:
X-Roundup-Name: Roundup issue tracker
X-Roundup-Loop: hello
Content-Transfer-Encoding: quoted-printable
John Doe added the comment:
This is a followup
----------
status: unread -> chatting
_______________________________________________________________________
Roundup issue tracker
_______________________________________________________________________
''')
def testFollowupNoNosyRecipients(self):
self.doNewIssue()
self.instance.config.ADD_RECIPIENTS_TO_NOSY = 'no'
self._send_mail('''Content-Type: text/plain;
charset="iso-8859-1"
From: richard@test
To: issue_tracker@your.tracker.email.domain.example
Cc: john@test
Message-Id:
In-Reply-To:
Subject: [issue1] Testing...
This is a followup
''')
self.compareMessages(self._get_mail(),
'''FROM: roundup-admin@your.tracker.email.domain.example
TO: chef@bork.bork.bork
Content-Type: text/plain; charset=utf-8
Subject: [issue1] Testing...
To: chef@bork.bork.bork
From: richard
Reply-To: Roundup issue tracker
MIME-Version: 1.0
Message-Id:
In-Reply-To:
X-Roundup-Name: Roundup issue tracker
X-Roundup-Loop: hello
Content-Transfer-Encoding: quoted-printable
richard added the comment:
This is a followup
----------
status: unread -> chatting
_______________________________________________________________________
Roundup issue tracker
_______________________________________________________________________
''')
def testFollowupEmptyMessage(self):
self.doNewIssue()
self._send_mail('''Content-Type: text/plain;
charset="iso-8859-1"
From: richard
To: issue_tracker@your.tracker.email.domain.example
Message-Id:
In-Reply-To:
Subject: [issue1] Testing... [assignedto=mary; nosy=+john]
''')
l = self.db.issue.get('1', 'nosy')
l.sort()
self.assertEqual(l, [self.chef_id, self.richard_id, self.mary_id,
self.john_id])
# should be no file created (ie. no message)
assert not os.path.exists(SENDMAILDEBUG)
def testNosyRemove(self):
self.doNewIssue()
self._send_mail('''Content-Type: text/plain;
charset="iso-8859-1"
From: richard
To: issue_tracker@your.tracker.email.domain.example
Message-Id:
In-Reply-To:
Subject: [issue1] Testing... [nosy=-richard]
''')
l = self.db.issue.get('1', 'nosy')
l.sort()
self.assertEqual(l, [self.chef_id])
# NO NOSY MESSAGE SHOULD BE SENT!
assert not os.path.exists(SENDMAILDEBUG)
def testNewUserAuthor(self):
# first without the permission
# heh... just ignore the API for a second ;)
self.db.security.role['anonymous'].permissions=[]
anonid = self.db.user.lookup('anonymous')
self.db.user.set(anonid, roles='Anonymous')
self.db.security.hasPermission('Email Registration', anonid)
l = self.db.user.list()
l.sort()
message = '''Content-Type: text/plain;
charset="iso-8859-1"
From: fubar
To: issue_tracker@your.tracker.email.domain.example
Message-Id:
Subject: [issue] Testing...
This is a test submission of a new issue.
'''
self.assertRaises(Unauthorized, self._send_mail, message)
m = self.db.user.list()
m.sort()
self.assertEqual(l, m)
# now with the permission
p = self.db.security.getPermission('Email Registration')
self.db.security.role['anonymous'].permissions=[p]
self._send_mail(message)
m = self.db.user.list()
m.sort()
self.assertNotEqual(l, m)
def testEnc01(self):
self.doNewIssue()
self._send_mail('''Content-Type: text/plain;
charset="iso-8859-1"
From: mary
To: issue_tracker@your.tracker.email.domain.example
Message-Id:
In-Reply-To:
Subject: [issue1] Testing...
Content-Type: text/plain;
charset="iso-8859-1"
Content-Transfer-Encoding: quoted-printable
A message with encoding (encoded oe =F6)
''')
self.compareMessages(self._get_mail(),
'''FROM: roundup-admin@your.tracker.email.domain.example
TO: chef@bork.bork.bork, richard@test
Content-Type: text/plain; charset=utf-8
Subject: [issue1] Testing...
To: chef@bork.bork.bork, richard@test
From: "Contrary, Mary"
Reply-To: Roundup issue tracker
MIME-Version: 1.0
Message-Id:
In-Reply-To:
X-Roundup-Name: Roundup issue tracker
X-Roundup-Loop: hello
Content-Transfer-Encoding: quoted-printable
Contrary, Mary added the comment:
A message with encoding (encoded oe =C3=B6)
----------
status: unread -> chatting
_______________________________________________________________________
Roundup issue tracker
_______________________________________________________________________
''')
def testMultipartEnc01(self):
self.doNewIssue()
self._send_mail('''Content-Type: text/plain;
charset="iso-8859-1"
From: mary
To: issue_tracker@your.tracker.email.domain.example
Message-Id:
In-Reply-To:
Subject: [issue1] Testing...
Content-Type: multipart/mixed;
boundary="----_=_NextPart_000_01"
This message is in MIME format. Since your mail reader does not understand
this format, some or all of this message may not be legible.
------_=_NextPart_000_01
Content-Type: text/plain;
charset="iso-8859-1"
Content-Transfer-Encoding: quoted-printable
A message with first part encoded (encoded oe =F6)
''')
self.compareMessages(self._get_mail(),
'''FROM: roundup-admin@your.tracker.email.domain.example
TO: chef@bork.bork.bork, richard@test
Content-Type: text/plain; charset=utf-8
Subject: [issue1] Testing...
To: chef@bork.bork.bork, richard@test
From: "Contrary, Mary"
Reply-To: Roundup issue tracker
MIME-Version: 1.0
Message-Id:
In-Reply-To:
X-Roundup-Name: Roundup issue tracker
X-Roundup-Loop: hello
Content-Transfer-Encoding: quoted-printable
Contrary, Mary added the comment:
A message with first part encoded (encoded oe =C3=B6)
----------
status: unread -> chatting
_______________________________________________________________________
Roundup issue tracker
_______________________________________________________________________
''')
def testContentDisposition(self):
self.doNewIssue()
self._send_mail('''Content-Type: text/plain;
charset="iso-8859-1"
From: mary
To: issue_tracker@your.tracker.email.domain.example
Message-Id:
In-Reply-To:
Subject: [issue1] Testing...
Content-Type: multipart/mixed; boundary="bCsyhTFzCvuiizWE"
Content-Disposition: inline
--bCsyhTFzCvuiizWE
Content-Type: text/plain; charset=us-ascii
Content-Disposition: inline
test attachment binary
--bCsyhTFzCvuiizWE
Content-Type: application/octet-stream
Content-Disposition: attachment; filename="main.dvi"
xxxxxx
--bCsyhTFzCvuiizWE--
''')
messages = self.db.issue.get('1', 'messages')
messages.sort()
file = self.db.msg.get(messages[-1], 'files')[0]
self.assertEqual(self.db.file.get(file, 'name'), 'main.dvi')
def testFollowupStupidQuoting(self):
self.doNewIssue()
self._send_mail('''Content-Type: text/plain;
charset="iso-8859-1"
From: richard
To: issue_tracker@your.tracker.email.domain.example
Message-Id:
In-Reply-To:
Subject: Re: "[issue1] Testing... "
This is a followup
''')
self.compareMessages(self._get_mail(),
'''FROM: roundup-admin@your.tracker.email.domain.example
TO: chef@bork.bork.bork
Content-Type: text/plain; charset=utf-8
Subject: [issue1] Testing...
To: chef@bork.bork.bork
From: richard
Reply-To: Roundup issue tracker
MIME-Version: 1.0
Message-Id:
In-Reply-To:
X-Roundup-Name: Roundup issue tracker
X-Roundup-Loop: hello
Content-Transfer-Encoding: quoted-printable
richard added the comment:
This is a followup
----------
status: unread -> chatting
_______________________________________________________________________
Roundup issue tracker
_______________________________________________________________________
''')
def testEmailQuoting(self):
self.instance.config.EMAIL_KEEP_QUOTED_TEXT = 'no'
self.innerTestQuoting('''This is a followup
''')
def testEmailQuotingRemove(self):
self.instance.config.EMAIL_KEEP_QUOTED_TEXT = 'yes'
self.innerTestQuoting('''Blah blah wrote:
> Blah bklaskdfj sdf asdf jlaskdf skj sdkfjl asdf
> skdjlkjsdfalsdkfjasdlfkj dlfksdfalksd fj
>
This is a followup
''')
def innerTestQuoting(self, expect):
nodeid = self.doNewIssue()
messages = self.db.issue.get(nodeid, 'messages')
self._send_mail('''Content-Type: text/plain;
charset="iso-8859-1"
From: richard
To: issue_tracker@your.tracker.email.domain.example
Message-Id:
In-Reply-To:
Subject: Re: [issue1] Testing...
Blah blah wrote:
> Blah bklaskdfj sdf asdf jlaskdf skj sdkfjl asdf
> skdjlkjsdfalsdkfjasdlfkj dlfksdfalksd fj
>
This is a followup
''')
# figure the new message id
newmessages = self.db.issue.get(nodeid, 'messages')
for msg in messages:
newmessages.remove(msg)
messageid = newmessages[0]
self.compareMessages(self.db.msg.get(messageid, 'content'), expect)
def testUserLookup(self):
i = self.db.user.create(username='user1', address='user1@foo.com')
self.assertEqual(uidFromAddress(self.db, ('', 'user1@foo.com'), 0), i)
self.assertEqual(uidFromAddress(self.db, ('', 'USER1@foo.com'), 0), i)
i = self.db.user.create(username='user2', address='USER2@foo.com')
self.assertEqual(uidFromAddress(self.db, ('', 'USER2@foo.com'), 0), i)
self.assertEqual(uidFromAddress(self.db, ('', 'user2@foo.com'), 0), i)
def testUserAlternateLookup(self):
i = self.db.user.create(username='user1', address='user1@foo.com',
alternate_addresses='user1@bar.com')
self.assertEqual(uidFromAddress(self.db, ('', 'user1@bar.com'), 0), i)
self.assertEqual(uidFromAddress(self.db, ('', 'USER1@bar.com'), 0), i)
def testUserCreate(self):
i = uidFromAddress(self.db, ('', 'user@foo.com'), 1)
self.assertNotEqual(uidFromAddress(self.db, ('', 'user@bar.com'), 1), i)
def testRFC2822(self):
ascii_header = "[issue243] This is a \"test\" - with 'quotation' marks"
unicode_header = '[issue244] \xd0\xb0\xd0\xbd\xd0\xb4\xd1\x80\xd0\xb5\xd0\xb9'
unicode_encoded = '=?utf-8?q?[issue244]_=D0=B0=D0=BD=D0=B4=D1=80=D0=B5=D0=B9?='
self.assertEqual(rfc2822.encode_header(ascii_header), ascii_header)
self.assertEqual(rfc2822.encode_header(unicode_header), unicode_encoded)
def testRegistrationConfirmation(self):
otk = "Aj4euk4LZSAdwePohj90SME5SpopLETL"
self.db.otks.set(otk, username='johannes', __time='')
self._send_mail('''Content-Type: text/plain;
charset="iso-8859-1"
From: Chef
To: issue_tracker@your.tracker.email.domain.example
Cc: richard@test
Message-Id:
Subject: Re: Complete your registration to Roundup issue tracker
-- key %s
This is a test confirmation of registration.
''' % otk)
self.db.user.lookup('johannes')
def testFollowupOnNonIssue(self):
self.db.keyword.create(name='Foo')
self._send_mail('''Content-Type: text/plain;
charset="iso-8859-1"
From: richard
To: issue_tracker@your.tracker.email.domain.example
Message-Id:
In-Reply-To:
Subject: [keyword1] Testing... [name=Bar]
''')
self.assertEqual(self.db.keyword.get('1', 'name'), 'Bar')
def testResentFrom(self):
nodeid = self._send_mail('''Content-Type: text/plain;
charset="iso-8859-1"
From: Chef
Resent-From: mary
To: issue_tracker@your.tracker.email.domain.example
Cc: richard@test
Message-Id:
Subject: [issue] Testing...
This is a test submission of a new issue.
''')
assert not os.path.exists(SENDMAILDEBUG)
l = self.db.issue.get(nodeid, 'nosy')
l.sort()
self.assertEqual(l, [self.richard_id, self.mary_id])
return nodeid
def testDejaVu(self):
self.assertRaises(IgnoreLoop, self._send_mail,
'''Content-Type: text/plain;
charset="iso-8859-1"
From: Chef
X-Roundup-Loop: hello
To: issue_tracker@your.tracker.email.domain.example
Cc: richard@test
Message-Id:
Subject: Re: [issue] Testing...
Hi, I've been mis-configured to loop messages back to myself.
''')
def testItsBulkStupid(self):
self.assertRaises(IgnoreBulk, self._send_mail,
'''Content-Type: text/plain;
charset="iso-8859-1"
From: Chef
Precedence: bulk
To: issue_tracker@your.tracker.email.domain.example
Cc: richard@test
Message-Id:
Subject: Re: [issue] Testing...
Hi, I'm on holidays, and this is a dumb auto-responder.
''')
def test_suite():
suite = unittest.TestSuite()
suite.addTest(unittest.makeSuite(MailgwTestCase))
return suite
if __name__ == '__main__':
runner = unittest.TextTestRunner()
unittest.main(testRunner=runner)
# vim: set filetype=python ts=4 sw=4 et si
code-7e4058dfb29b/test/test_mailsplit.py 0000644 0000000 0000000 00000021203 07763742201 016335 0 ustar 0000000 0000000 #
# Copyright (c) 2001 Bizar Software Pty Ltd (http://www.bizarsoftware.com.au/)
# This module is free software, and you may redistribute it and/or modify
# under the same terms as Python, so long as this copyright message and
# disclaimer are retained in their original form.
#
# IN NO EVENT SHALL BIZAR SOFTWARE PTY LTD BE LIABLE TO ANY PARTY FOR
# DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING
# OUT OF THE USE OF THIS CODE, EVEN IF THE AUTHOR HAS BEEN ADVISED OF THE
# POSSIBILITY OF SUCH DAMAGE.
#
# BIZAR SOFTWARE PTY LTD SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING,
# BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
# FOR A PARTICULAR PURPOSE. THE CODE PROVIDED HEREUNDER IS ON AN "AS IS"
# BASIS, AND THERE IS NO OBLIGATION WHATSOEVER TO PROVIDE MAINTENANCE,
# SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
#
# $Id: test_mailsplit.py,v 1.15 2003-10-25 22:53:26 richard Exp $
import unittest, cStringIO
from roundup.mailgw import parseContent
class MailsplitTestCase(unittest.TestCase):
def testPreComment(self):
s = '''
blah blah blah blah... blah blah? blah blah blah blah blah. blah blah blah
blah blah blah blah blah blah blah blah blah blah blah!
issue_tracker@foo.com wrote:
> blah blah blah blahblah blahblah blahblah blah blah blah blah blah blah
> blah blah blah blah blah blah blah blah blah? blah blah blah blah blah
> blah blah blah blah blah blah blah... blah blah blah blah. blah blah
> blah blah blah blah? blah blah blah blah blah blah! blah blah!
>
> -------
> nosy: userfoo, userken
> _________________________________________________
> Roundup issue tracker
> issue_tracker@foo.com
> http://foo.com/cgi-bin/roundup.cgi/issue_tracker/
--
blah blah blah signature
userfoo@foo.com
'''
summary, content = parseContent(s, 0, 0)
self.assertEqual(summary, 'blah blah blah blah... blah blah? blah blah blah blah blah. blah blah blah')
self.assertEqual(content, 'blah blah blah blah... blah blah? blah blah blah blah blah. blah blah blah\nblah blah blah blah blah blah blah blah blah blah blah!')
def testPostComment(self):
s = '''
issue_tracker@foo.com wrote:
> blah blah blah blahblah blahblah blahblah blah blah blah blah blah
> blah
> blah blah blah blah blah blah blah blah blah? blah blah blah blah
> blah
> blah blah blah blah blah blah blah... blah blah blah blah. blah
> blah
> blah blah blah blah? blah blah blah blah blah blah! blah blah!
>
> -------
> nosy: userfoo, userken
> _________________________________________________
> Roundup issue tracker
> issue_tracker@foo.com
> http://foo.com/cgi-bin/roundup.cgi/issue_tracker/
blah blah blah blah... blah blah? blah blah blah blah blah. blah blah blah
blah blah blah blah blah blah blah blah blah blah blah!
--
blah blah blah signature
userfoo@foo.com
'''
summary, content = parseContent(s, 0, 0)
self.assertEqual(summary, 'blah blah blah blah... blah blah? blah blah blah blah blah. blah blah blah')
self.assertEqual(content, 'blah blah blah blah... blah blah? blah blah blah blah blah. blah blah blah\nblah blah blah blah blah blah blah blah blah blah blah!')
def testKeepCitation(self):
s = '''
blah blah blah blah... blah blah? blah blah blah blah blah. blah blah blah
blah blah blah blah blah blah blah blah blah blah blah!
issue_tracker@foo.com wrote:
> blah blah blah blahblah blahblah blahblah blah blah blah blah blah blah
> blah blah blah blah blah blah blah blah blah? blah blah blah blah blah
> blah blah blah blah blah blah blah... blah blah blah blah. blah blah
> blah blah blah blah? blah blah blah blah blah blah! blah blah!
>
> -------
> nosy: userfoo, userken
> _________________________________________________
> Roundup issue tracker
> issue_tracker@foo.com
> http://foo.com/cgi-bin/roundup.cgi/issue_tracker/
--
blah blah blah signature
userfoo@foo.com
'''
summary, content = parseContent(s, 1, 0)
self.assertEqual(summary, 'blah blah blah blah... blah blah? blah blah blah blah blah. blah blah blah')
self.assertEqual(content, '''\
blah blah blah blah... blah blah? blah blah blah blah blah. blah blah blah
blah blah blah blah blah blah blah blah blah blah blah!
issue_tracker@foo.com wrote:
> blah blah blah blahblah blahblah blahblah blah blah blah blah blah blah
> blah blah blah blah blah blah blah blah blah? blah blah blah blah blah
> blah blah blah blah blah blah blah... blah blah blah blah. blah blah
> blah blah blah blah? blah blah blah blah blah blah! blah blah!
>
> -------
> nosy: userfoo, userken
> _________________________________________________
> Roundup issue tracker
> issue_tracker@foo.com
> http://foo.com/cgi-bin/roundup.cgi/issue_tracker/''')
def testKeepBody(self):
s = '''
blah blah blah blah... blah blah? blah blah blah blah blah. blah blah blah
blah blah blah blah blah blah blah blah blah blah blah!
issue_tracker@foo.com wrote:
> blah blah blah blahblah blahblah blahblah blah blah blah blah blah blah
> blah blah blah blah blah blah blah blah blah? blah blah blah blah blah
> blah blah blah blah blah blah blah... blah blah blah blah. blah blah
> blah blah blah blah? blah blah blah blah blah blah! blah blah!
>
> -------
> nosy: userfoo, userken
> _________________________________________________
> Roundup issue tracker
> issue_tracker@foo.com
> http://foo.com/cgi-bin/roundup.cgi/issue_tracker/
--
blah blah blah signature
userfoo@foo.com
'''
summary, content = parseContent(s, 0, 1)
self.assertEqual(summary, 'blah blah blah blah... blah blah? blah blah blah blah blah. blah blah blah')
self.assertEqual(content, '''
blah blah blah blah... blah blah? blah blah blah blah blah. blah blah blah
blah blah blah blah blah blah blah blah blah blah blah!
issue_tracker@foo.com wrote:
> blah blah blah blahblah blahblah blahblah blah blah blah blah blah blah
> blah blah blah blah blah blah blah blah blah? blah blah blah blah blah
> blah blah blah blah blah blah blah... blah blah blah blah. blah blah
> blah blah blah blah? blah blah blah blah blah blah! blah blah!
>
> -------
> nosy: userfoo, userken
> _________________________________________________
> Roundup issue tracker
> issue_tracker@foo.com
> http://foo.com/cgi-bin/roundup.cgi/issue_tracker/
--
blah blah blah signature
userfoo@foo.com
''')
def testAllQuoted(self):
s = '\nissue_tracker@foo.com wrote:\n> testing\n'
summary, content = parseContent(s, 0, 1)
self.assertEqual(summary, '')
self.assertEqual(content, s)
def testSimple(self):
s = '''testing'''
summary, content = parseContent(s, 0, 0)
self.assertEqual(summary, 'testing')
self.assertEqual(content, 'testing')
def testParagraphs(self):
s = '''testing\n\ntesting\n\ntesting'''
summary, content = parseContent(s, 0, 0)
self.assertEqual(summary, 'testing')
self.assertEqual(content, 'testing\n\ntesting\n\ntesting')
def testSimpleFollowup(self):
s = '''>hello\ntesting'''
summary, content = parseContent(s, 0, 0)
self.assertEqual(summary, 'testing')
self.assertEqual(content, 'testing')
def testSimpleFollowupParas(self):
s = '''>hello\ntesting\n\ntesting\n\ntesting'''
summary, content = parseContent(s, 0, 0)
self.assertEqual(summary, 'testing')
self.assertEqual(content, 'testing\n\ntesting\n\ntesting')
def testEmpty(self):
s = ''
summary, content = parseContent(s, 0, 0)
self.assertEqual(summary, '')
self.assertEqual(content, '')
def testIndentationSummary(self):
s = ' Four space indent.\n\n Four space indent.\nNo indent.'
summary, content = parseContent(s, 0, 0)
self.assertEqual(summary, ' Four space indent.')
def testIndentationContent(self):
s = ' Four space indent.\n\n Four space indent.\nNo indent.'
summary, content = parseContent(s, 0, 0)
self.assertEqual(content, s)
def testMultilineSummary(self):
s = 'This is a long sentence that would normally\nbe split. More words.'
summary, content = parseContent(s, 0, 0)
self.assertEqual(summary, 'This is a long sentence that would '
'normally\nbe split.')
def testKeepMultipleHyphens(self):
body = '''Testing, testing.
----
Testing, testing.'''
summary, content = parseContent(body, 1, 0)
self.assertEqual(body, content)
def test_suite():
suite = unittest.TestSuite()
suite.addTest(unittest.makeSuite(MailsplitTestCase))
return suite
if __name__ == '__main__':
runner = unittest.TextTestRunner()
unittest.main(testRunner=runner)
# vim: set filetype=python ts=4 sw=4 et si
code-7e4058dfb29b/test/test_metakit.py 0000644 0000000 0000000 00000010076 07763742201 016003 0 ustar 0000000 0000000 #
# Copyright (c) 2001 Bizar Software Pty Ltd (http://www.bizarsoftware.com.au/)
# This module is free software, and you may redistribute it and/or modify
# under the same terms as Python, so long as this copyright message and
# disclaimer are retained in their original form.
#
# IN NO EVENT SHALL BIZAR SOFTWARE PTY LTD BE LIABLE TO ANY PARTY FOR
# DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING
# OUT OF THE USE OF THIS CODE, EVEN IF THE AUTHOR HAS BEEN ADVISED OF THE
# POSSIBILITY OF SUCH DAMAGE.
#
# BIZAR SOFTWARE PTY LTD SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING,
# BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
# FOR A PARTICULAR PURPOSE. THE CODE PROVIDED HEREUNDER IS ON AN "AS IS"
# BASIS, AND THERE IS NO OBLIGATION WHATSOEVER TO PROVIDE MAINTENANCE,
# SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
#
# $Id: test_metakit.py,v 1.2 2003-11-14 00:11:19 richard Exp $
import unittest, os, shutil, time, weakref
from db_test_base import DBTest, ROTest, SchemaTest, ClassicInitTest, config
from roundup import backends
class metakitOpener:
if hasattr(backends, 'metakit'):
from roundup.backends import metakit as module
module._instances = weakref.WeakValueDictionary()
def nuke_database(self):
shutil.rmtree(config.DATABASE)
class metakitDBTest(metakitOpener, DBTest):
def 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 metakitROTest(metakitOpener, ROTest):
pass
class metakitSchemaTest(metakitOpener, SchemaTest):
pass
class metakitClassicInitTest(ClassicInitTest):
backend = 'metakit'
def test_suite():
suite = unittest.TestSuite()
if not hasattr(backends, 'metakit'):
print 'Skipping metakit tests'
return suite
print 'Including metakit tests'
suite.addTest(unittest.makeSuite(metakitDBTest))
suite.addTest(unittest.makeSuite(metakitROTest))
suite.addTest(unittest.makeSuite(metakitSchemaTest))
suite.addTest(unittest.makeSuite(metakitClassicInitTest))
return suite
if __name__ == '__main__':
runner = unittest.TextTestRunner()
unittest.main(testRunner=runner)
code-7e4058dfb29b/test/test_multipart.py 0000644 0000000 0000000 00000007413 07763742201 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.6 2003-10-25 22:53:26 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 test_suite():
suite = unittest.TestSuite()
suite.addTest(unittest.makeSuite(MultipartTestCase))
return suite
if __name__ == '__main__':
runner = unittest.TextTestRunner()
unittest.main(testRunner=runner)
# vim: set filetype=python ts=4 sw=4 et si
code-7e4058dfb29b/test/test_mysql.py 0000644 0000000 0000000 00000007166 07763742201 015520 0 ustar 0000000 0000000 #
# Copyright (c) 2001 Bizar Software Pty Ltd (http://www.bizarsoftware.com.au/)
# This module is free software, and you may redistribute it and/or modify
# under the same terms as Python, so long as this copyright message and
# disclaimer are retained in their original form.
#
# IN NO EVENT SHALL BIZAR SOFTWARE PTY LTD BE LIABLE TO ANY PARTY FOR
# DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING
# OUT OF THE USE OF THIS CODE, EVEN IF THE AUTHOR HAS BEEN ADVISED OF THE
# POSSIBILITY OF SUCH DAMAGE.
#
# BIZAR SOFTWARE PTY LTD SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING,
# BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
# FOR A PARTICULAR PURPOSE. THE CODE PROVIDED HEREUNDER IS ON AN "AS IS"
# BASIS, AND THERE IS NO OBLIGATION WHATSOEVER TO PROVIDE MAINTENANCE,
# SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
#
# $Id: test_mysql.py,v 1.6 2003-11-14 00:11:19 richard Exp $
import unittest, os, shutil, time, imp
from roundup.hyperdb import DatabaseError
from roundup import init, backends
from db_test_base import DBTest, ROTest, config, SchemaTest, ClassicInitTest
# Mysql connection data
config.MYSQL_DBHOST = 'localhost'
config.MYSQL_DBUSER = 'rounduptest'
config.MYSQL_DBPASSWORD = 'rounduptest'
config.MYSQL_DBNAME = 'rounduptest'
config.MYSQL_DATABASE = (config.MYSQL_DBHOST, config.MYSQL_DBUSER,
config.MYSQL_DBPASSWORD, config.MYSQL_DBNAME)
class nodbconfig(config):
MYSQL_DATABASE = (config.MYSQL_DBHOST, config.MYSQL_DBUSER, config.MYSQL_DBPASSWORD)
class mysqlOpener:
if hasattr(backends, 'mysql'):
from roundup.backends import mysql as module
def tearDown(self):
self.db.close()
self.nuke_database()
def nuke_database(self):
self.module.db_nuke(config)
class mysqlDBTest(mysqlOpener, DBTest):
pass
class mysqlROTest(mysqlOpener, ROTest):
pass
class mysqlSchemaTest(mysqlOpener, SchemaTest):
pass
class mysqlClassicInitTest(mysqlOpener, ClassicInitTest):
backend = 'mysql'
extra_config = '''
MYSQL_DBHOST = 'localhost'
MYSQL_DBUSER = 'rounduptest'
MYSQL_DBPASSWORD = 'rounduptest'
MYSQL_DBNAME = 'rounduptest'
MYSQL_DATABASE = (MYSQL_DBHOST, MYSQL_DBUSER, MYSQL_DBPASSWORD, MYSQL_DBNAME)
'''
if hasattr(backends, 'mysql'):
from roundup.backends import mysql as module
def tearDown(self):
ClassicInitTest.tearDown(self)
self.nuke_database()
def test_suite():
suite = unittest.TestSuite()
if not hasattr(backends, 'mysql'):
return suite
from roundup.backends import mysql
try:
# Check if we can run mysql tests
import MySQLdb
db = mysql.Database(config, 'admin')
db.conn.select_db(config.MYSQL_DBNAME)
db.sql("SHOW TABLES");
tables = db.sql_fetchall()
# TODO: reinstate the check here
if 0: #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 "Skipping mysql tests (%s)"%msg
else:
print 'Including mysql tests'
suite.addTest(unittest.makeSuite(mysqlDBTest))
suite.addTest(unittest.makeSuite(mysqlROTest))
suite.addTest(unittest.makeSuite(mysqlSchemaTest))
suite.addTest(unittest.makeSuite(mysqlClassicInitTest))
return suite
if __name__ == '__main__':
runner = unittest.TextTestRunner()
unittest.main(testRunner=runner)
code-7e4058dfb29b/test/test_postgresql.py 0000644 0000000 0000000 00000011060 07763742201 016542 0 ustar 0000000 0000000 #
# Copyright (c) 2001 Bizar Software Pty Ltd (http://www.bizarsoftware.com.au/)
# This module is free software, and you may redistribute it and/or modify
# under the same terms as Python, so long as this copyright message and
# disclaimer are retained in their original form.
#
# IN NO EVENT SHALL BIZAR SOFTWARE PTY LTD BE LIABLE TO ANY PARTY FOR
# DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING
# OUT OF THE USE OF THIS CODE, EVEN IF THE AUTHOR HAS BEEN ADVISED OF THE
# POSSIBILITY OF SUCH DAMAGE.
#
# BIZAR SOFTWARE PTY LTD SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING,
# BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
# FOR A PARTICULAR PURPOSE. THE CODE PROVIDED HEREUNDER IS ON AN "AS IS"
# BASIS, AND THERE IS NO OBLIGATION WHATSOEVER TO PROVIDE MAINTENANCE,
# SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
#
# $Id: test_postgresql.py,v 1.4 2003-11-14 00:11:19 richard Exp $
import sys, unittest, os, shutil, time, popen2
from roundup.hyperdb import DatabaseError
from db_test_base import DBTest, ROTest, config, SchemaTest, ClassicInitTest
# Postgresql connection data
# NOTE: THIS MUST BE A LOCAL DATABASE
config.POSTGRESQL_DATABASE = {'database': 'rounduptest'}
from roundup import backends
def db_create():
"""Clear all database contents and drop database itself"""
name = config.POSTGRESQL_DATABASE['database']
cout,cin = popen2.popen4('createdb %s'%name)
cin.close()
response = cout.read().split('\n')[0]
if response.find('FATAL') != -1 or response.find('ERROR') != -1:
raise RuntimeError, response
def db_nuke(fail_ok=0):
"""Clear all database contents and drop database itself"""
name = config.POSTGRESQL_DATABASE['database']
cout,cin = popen2.popen4('dropdb %s'%name)
cin.close()
response = cout.read().split('\n')[0]
if response.endswith('does not exist') and fail_ok:
return
if response.find('FATAL') != -1 or response.find('ERROR') != -1:
raise RuntimeError, response
if os.path.exists(config.DATABASE):
shutil.rmtree(config.DATABASE)
def db_exists(config):
"""Check if database already exists"""
try:
db = Database(config, 'admin')
return 1
except:
return 0
class postgresqlOpener:
if hasattr(backends, 'postgresql'):
from roundup.backends import postgresql as module
def setUp(self):
db_nuke(1)
db_create()
def tearDown(self):
self.nuke_database()
def nuke_database(self):
# clear out the database - easiest way is to nuke and re-created it
db_nuke()
db_create()
class postgresqlDBTest(postgresqlOpener, DBTest):
def setUp(self):
postgresqlOpener.setUp(self)
DBTest.setUp(self)
def tearDown(self):
DBTest.tearDown(self)
postgresqlOpener.tearDown(self)
def testFilteringIntervalSort(self):
# PostgreSQL sorts NULLs differently to other databases (others
# treat it as lower than real values, PG treats it as higher)
ae, filt = self.filteringSetup()
# ascending should sort None, 1:10, 1d
ae(filt(None, {}, ('+','foo'), (None,None)), ['4', '1', '2', '3'])
# descending should sort 1d, 1:10, None
ae(filt(None, {}, ('-','foo'), (None,None)), ['3', '2', '1', '4'])
class postgresqlROTest(postgresqlOpener, ROTest):
def setUp(self):
postgresqlOpener.setUp(self)
ROTest.setUp(self)
def tearDown(self):
ROTest.tearDown(self)
postgresqlOpener.tearDown(self)
class postgresqlSchemaTest(postgresqlOpener, SchemaTest):
def setUp(self):
postgresqlOpener.setUp(self)
SchemaTest.setUp(self)
def tearDown(self):
SchemaTest.tearDown(self)
postgresqlOpener.tearDown(self)
class postgresqlClassicInitTest(postgresqlOpener, ClassicInitTest):
backend = 'postgresql'
extra_config = "POSTGRESQL_DATABASE = {'database': 'rounduptest'}"
def setUp(self):
postgresqlOpener.setUp(self)
ClassicInitTest.setUp(self)
def tearDown(self):
ClassicInitTest.tearDown(self)
postgresqlOpener.tearDown(self)
def test_suite():
suite = unittest.TestSuite()
if not hasattr(backends, 'postgresql'):
return suite
# Check if we can run postgresql tests
print 'Including postgresql tests'
suite.addTest(unittest.makeSuite(postgresqlDBTest))
suite.addTest(unittest.makeSuite(postgresqlROTest))
suite.addTest(unittest.makeSuite(postgresqlSchemaTest))
suite.addTest(unittest.makeSuite(postgresqlClassicInitTest))
return suite
code-7e4058dfb29b/test/test_schema.py 0000644 0000000 0000000 00000007241 07763742201 015605 0 ustar 0000000 0000000 #
# Copyright (c) 2001 Bizar Software Pty Ltd (http://www.bizarsoftware.com.au/)
# This module is free software, and you may redistribute it and/or modify
# under the same terms as Python, so long as this copyright message and
# disclaimer are retained in their original form.
#
# IN NO EVENT SHALL BIZAR SOFTWARE PTY LTD BE LIABLE TO ANY PARTY FOR
# DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING
# OUT OF THE USE OF THIS CODE, EVEN IF THE AUTHOR HAS BEEN ADVISED OF THE
# POSSIBILITY OF SUCH DAMAGE.
#
# BIZAR SOFTWARE PTY LTD SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING,
# BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
# FOR A PARTICULAR PURPOSE. THE CODE PROVIDED HEREUNDER IS ON AN "AS IS"
# BASIS, AND THERE IS NO OBLIGATION WHATSOEVER TO PROVIDE MAINTENANCE,
# SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
#
# $Id: test_schema.py,v 1.13 2003-10-25 22:53:26 richard Exp $
import unittest, os, shutil
from roundup.backends import back_anydbm
from roundup.hyperdb import String, Password, Link, Multilink, Date, \
Interval
class config:
DATABASE='_test_dir'
MAILHOST = 'localhost'
MAIL_DOMAIN = 'fill.me.in.'
NSTANCE_NAME = 'Roundup issue tracker'
TRACKER_EMAIL = 'issue_tracker@%s'%MAIL_DOMAIN
TRACKER_WEB = 'http://some.useful.url/'
ADMIN_EMAIL = 'roundup-admin@%s'%MAIL_DOMAIN
FILTER_POSITION = 'bottom' # one of 'top', 'bottom', 'top and bottom'
ANONYMOUS_ACCESS = 'deny' # either 'deny' or 'allow'
ANONYMOUS_REGISTER = 'deny' # either 'deny' or 'allow'
MESSAGES_TO_AUTHOR = 'no' # either 'yes' or 'no'
EMAIL_SIGNATURE_POSITION = 'bottom'
class SchemaTestCase(unittest.TestCase):
def setUp(self):
# remove previous test, ignore errors
if os.path.exists(config.DATABASE):
shutil.rmtree(config.DATABASE)
os.makedirs(config.DATABASE + '/files')
self.db = back_anydbm.Database(config, 'admin')
self.db.post_init()
self.db.clear()
def tearDown(self):
self.db.close()
shutil.rmtree('_test_dir')
def testA_Status(self):
status = back_anydbm.Class(self.db, "status", name=String())
self.assert_(status, 'no class object generated')
status.setkey("name")
val = status.create(name="unread")
self.assertEqual(val, '1', 'expecting "1"')
val = status.create(name="in-progress")
self.assertEqual(val, '2', 'expecting "2"')
val = status.create(name="testing")
self.assertEqual(val, '3', 'expecting "3"')
val = status.create(name="resolved")
self.assertEqual(val, '4', 'expecting "4"')
val = status.count()
self.assertEqual(val, 4, 'expecting 4')
val = status.list()
self.assertEqual(val, ['1', '2', '3', '4'], 'blah')
val = status.lookup("in-progress")
self.assertEqual(val, '2', 'expecting "2"')
status.retire('3')
val = status.list()
self.assertEqual(val, ['1', '2', '4'], 'blah')
def testB_Issue(self):
issue = back_anydbm.Class(self.db, "issue", title=String(),
status=Link("status"))
self.assert_(issue, 'no class object returned')
def testC_User(self):
user = back_anydbm.Class(self.db, "user", username=String(),
password=Password())
self.assert_(user, 'no class object returned')
user.setkey("username")
def test_suite():
suite = unittest.TestSuite()
suite.addTest(unittest.makeSuite(SchemaTestCase))
return suite
if __name__ == '__main__':
runner = unittest.TextTestRunner()
unittest.main(testRunner=runner)
# vim: set filetype=python ts=4 sw=4 et si
code-7e4058dfb29b/test/test_security.py 0000644 0000000 0000000 00000011531 07763742201 016211 0 ustar 0000000 0000000 # Copyright (c) 2002 ekit.com Inc (http://www.ekit-inc.com/)
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in
# all copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
# SOFTWARE.
# $Id: test_security.py,v 1.6 2003-10-25 22:53:26 richard Exp $
import os, unittest, shutil
from roundup.password import Password
from db_test_base import setupSchema, MyTestCase, config
class PermissionTest(MyTestCase):
def setUp(self):
from roundup.backends import anydbm
# remove previous test, ignore errors
if os.path.exists(config.DATABASE):
shutil.rmtree(config.DATABASE)
os.makedirs(config.DATABASE + '/files')
self.db = anydbm.Database(config, 'admin')
setupSchema(self.db, 1, anydbm)
def testInterfaceSecurity(self):
' test that the CGI and mailgw have initialised security OK '
# TODO: some asserts
def testInitialiseSecurity(self):
''' Create some Permissions and Roles on the security object
This function is directly invoked by security.Security.__init__()
as a part of the Security object instantiation.
'''
ei = self.db.security.addPermission(name="Edit", klass="issue",
description="User is allowed to edit issues")
self.db.security.addPermissionToRole('User', ei)
ai = self.db.security.addPermission(name="View", klass="issue",
description="User is allowed to access issues")
self.db.security.addPermissionToRole('User', ai)
def testGetPermission(self):
self.db.security.getPermission('Edit')
self.db.security.getPermission('View')
self.assertRaises(ValueError, self.db.security.getPermission, 'x')
self.assertRaises(ValueError, self.db.security.getPermission, 'Edit',
'fubar')
ei = self.db.security.addPermission(name="Edit", klass="issue",
description="User is allowed to edit issues")
self.db.security.getPermission('Edit', 'issue')
ai = self.db.security.addPermission(name="View", klass="issue",
description="User is allowed to access issues")
self.db.security.getPermission('View', 'issue')
def testDBinit(self):
self.db.user.create(username="anonymous", roles='User')
def testAccessControls(self):
self.testDBinit()
ei = self.db.security.addPermission(name="Edit", klass="issue",
description="User is allowed to edit issues")
self.db.security.addPermissionToRole('User', ei)
# test class-level access
userid = self.db.user.lookup('admin')
self.assertEquals(self.db.security.hasPermission('Edit', userid,
'issue'), 1)
self.assertEquals(self.db.security.hasPermission('Edit', userid,
'user'), 1)
userid = self.db.user.lookup('anonymous')
self.assertEquals(self.db.security.hasPermission('Edit', userid,
'issue'), 1)
self.assertEquals(self.db.security.hasPermission('Edit', userid,
'user'), 0)
self.assertEquals(self.db.security.hasPermission('View', userid,
'issue'), 0)
# test node-level access
issueid = self.db.issue.create(title='foo', assignedto='admin')
userid = self.db.user.lookup('admin')
self.assertEquals(self.db.security.hasNodePermission('issue',
issueid, assignedto=userid), 1)
self.assertEquals(self.db.security.hasNodePermission('issue',
issueid, nosy=userid), 0)
self.db.issue.set(issueid, nosy=[userid])
self.assertEquals(self.db.security.hasNodePermission('issue',
issueid, nosy=userid), 1)
def test_suite():
suite = unittest.TestSuite()
suite.addTest(unittest.makeSuite(PermissionTest))
return suite
if __name__ == '__main__':
runner = unittest.TextTestRunner()
unittest.main(testRunner=runner)
# vim: set filetype=python ts=4 sw=4 et si
code-7e4058dfb29b/test/test_sqlite.py 0000644 0000000 0000000 00000004021 07763742201 015637 0 ustar 0000000 0000000 #
# Copyright (c) 2001 Bizar Software Pty Ltd (http://www.bizarsoftware.com.au/)
# This module is free software, and you may redistribute it and/or modify
# under the same terms as Python, so long as this copyright message and
# disclaimer are retained in their original form.
#
# IN NO EVENT SHALL BIZAR SOFTWARE PTY LTD BE LIABLE TO ANY PARTY FOR
# DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING
# OUT OF THE USE OF THIS CODE, EVEN IF THE AUTHOR HAS BEEN ADVISED OF THE
# POSSIBILITY OF SUCH DAMAGE.
#
# BIZAR SOFTWARE PTY LTD SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING,
# BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
# FOR A PARTICULAR PURPOSE. THE CODE PROVIDED HEREUNDER IS ON AN "AS IS"
# BASIS, AND THERE IS NO OBLIGATION WHATSOEVER TO PROVIDE MAINTENANCE,
# SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
#
# $Id: test_sqlite.py,v 1.3 2003-11-14 00:11:19 richard Exp $
import unittest, os, shutil, time
from db_test_base import DBTest, ROTest, SchemaTest, ClassicInitTest, config
class sqliteOpener:
from roundup import backends
if hasattr(backends, 'sqlite'):
from roundup.backends import sqlite as module
def nuke_database(self):
shutil.rmtree(config.DATABASE)
class sqliteDBTest(sqliteOpener, DBTest):
pass
class sqliteROTest(sqliteOpener, ROTest):
pass
class sqliteSchemaTest(sqliteOpener, SchemaTest):
pass
class sqliteClassicInitTest(ClassicInitTest):
backend = 'sqlite'
def test_suite():
suite = unittest.TestSuite()
from roundup import backends
if not hasattr(backends, 'sqlite'):
print 'Skipping sqlite tests'
return suite
print 'Including sqlite tests'
suite.addTest(unittest.makeSuite(sqliteDBTest))
suite.addTest(unittest.makeSuite(sqliteROTest))
suite.addTest(unittest.makeSuite(sqliteSchemaTest))
suite.addTest(unittest.makeSuite(sqliteClassicInitTest))
return suite
if __name__ == '__main__':
runner = unittest.TextTestRunner()
unittest.main(testRunner=runner)
code-7e4058dfb29b/test/test_token.py 0000644 0000000 0000000 00000003744 07763742201 015471 0 ustar 0000000 0000000 #
# Copyright (c) 2001 Richard Jones
# This module is free software, and you may redistribute it and/or modify
# under the same terms as Python, so long as this copyright message and
# disclaimer are retained in their original form.
#
# This module is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
#
# $Id: test_token.py,v 1.3 2003-10-25 22:53:26 richard Exp $
import unittest, time
from roundup.token import token_split
class TokenTestCase(unittest.TestCase):
def testValid(self):
l = token_split('hello world')
self.assertEqual(l, ['hello', 'world'])
def testIgnoreExtraSpace(self):
l = token_split('hello world ')
self.assertEqual(l, ['hello', 'world'])
def testQuoting(self):
l = token_split('"hello world"')
self.assertEqual(l, ['hello world'])
l = token_split("'hello world'")
self.assertEqual(l, ['hello world'])
def testEmbedQuote(self):
l = token_split(r'Roch\'e Compaan')
self.assertEqual(l, ["Roch'e", "Compaan"])
l = token_split('address="1 2 3"')
self.assertEqual(l, ['address=1 2 3'])
def testEscaping(self):
l = token_split('"Roch\'e" Compaan')
self.assertEqual(l, ["Roch'e", "Compaan"])
l = token_split(r'hello\ world')
self.assertEqual(l, ['hello world'])
l = token_split(r'\\')
self.assertEqual(l, ['\\'])
l = token_split(r'\n')
self.assertEqual(l, ['\n'])
def testBadQuote(self):
self.assertRaises(ValueError, token_split, '"hello world')
self.assertRaises(ValueError, token_split, "Roch'e Compaan")
def test_suite():
suite = unittest.TestSuite()
suite.addTest(unittest.makeSuite(TokenTestCase))
return suite
if __name__ == '__main__':
runner = unittest.TextTestRunner()
unittest.main(testRunner=runner)
# vim: set filetype=python ts=4 sw=4 et si