test/db_test_base.py

   1 #
   2 # Copyright (c) 2001 Bizar Software Pty Ltd (http://www.bizarsoftware.com.au/)
   3 # This module is free software, and you may redistribute it and/or modify
   4 # under the same terms as Python, so long as this copyright message and
   5 # disclaimer are retained in their original form.
   6 #
   7 # IN NO EVENT SHALL BIZAR SOFTWARE PTY LTD BE LIABLE TO ANY PARTY FOR
   8 # DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING
   9 # OUT OF THE USE OF THIS CODE, EVEN IF THE AUTHOR HAS BEEN ADVISED OF THE
  10 # POSSIBILITY OF SUCH DAMAGE.
  11 #
  12 # BIZAR SOFTWARE PTY LTD SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING,
  13 # BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
  14 # FOR A PARTICULAR PURPOSE.  THE CODE PROVIDED HEREUNDER IS ON AN "AS IS"
  15 # BASIS, AND THERE IS NO OBLIGATION WHATSOEVER TO PROVIDE MAINTENANCE,
  16 # SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
  17 #
  18 # $Id: db_test_base.py,v 1.101 2008-08-19 01:40:59 richard Exp $
  19
  20 import unittest, os, shutil, errno, imp, sys, time, pprint, base64, os.path
  21 # Python 2.3 ... 2.6 compatibility:
  22 from roundup.anypy.sets_ import set
  23
  24 from roundup.hyperdb import String, Password, Link, Multilink, Date, \
  25     Interval, DatabaseError, Boolean, Number, Node
  26 from roundup.mailer import Mailer
  27 from roundup import date, password, init, instance, configuration, \
  28     roundupdb, i18n
  29
  30 from mocknull import MockNull
  31
  32 config = configuration.CoreConfig()
  33 config.DATABASE = "db"
  34 config.RDBMS_NAME = "rounduptest"
  35 config.RDBMS_HOST = "localhost"
  36 config.RDBMS_USER = "rounduptest"
  37 config.RDBMS_PASSWORD = "rounduptest"
  38 config.RDBMS_TEMPLATE = "template0"
  39 #config.logging = MockNull()
  40 # these TRACKER_WEB and MAIL_DOMAIN values are used in mailgw tests
  41 config.MAIL_DOMAIN = "your.tracker.email.domain.example"
  42 config.TRACKER_WEB = "http://tracker.example/cgi-bin/roundup.cgi/bugs/"
  43 # uncomment the following to have excessive debug output from test cases
  44 # FIXME: tracker logging level should be increased by -v arguments
  45 #   to 'run_tests.py' script
  46 #config.LOGGING_FILENAME = "/tmp/logfile"
  47 #config.LOGGING_LEVEL = "DEBUG"
  48 config.init_logging()
  49
  50 def setupTracker(dirname, backend="anydbm"):
  51     """Install and initialize new tracker in dirname; return tracker instance.
  52
  53     If the directory exists, it is wiped out before the operation.
  54
  55     """
  56     global config
  57     try:
  58         shutil.rmtree(dirname)
  59     except OSError, error:
  60         if error.errno not in (errno.ENOENT, errno.ESRCH): raise
  61     # create the instance
  62     init.install(dirname, os.path.join(os.path.dirname(__file__),
  63                                        '..',
  64                                        'share',
  65                                        'roundup',
  66                                        'templates',
  67                                        'classic'))
  68     init.write_select_db(dirname, backend)
  69     config.save(os.path.join(dirname, 'config.ini'))
  70     tracker = instance.open(dirname)
  71     if tracker.exists():
  72         tracker.nuke()
  73         init.write_select_db(dirname, backend)
  74     tracker.init(password.Password('sekrit'))
  75     return tracker
  76
  77 def setupSchema(db, create, module):
  78     status = module.Class(db, "status", name=String())
  79     status.setkey("name")
  80     priority = module.Class(db, "priority", name=String(), order=String())
  81     priority.setkey("name")
  82     user = module.Class(db, "user", username=String(), password=Password(),
  83         assignable=Boolean(), age=Number(), roles=String(), address=String(),
  84         supervisor=Link('user'),realname=String())
  85     user.setkey("username")
  86     file = module.FileClass(db, "file", name=String(), type=String(),
  87         comment=String(indexme="yes"), fooz=Password())
  88     file_nidx = module.FileClass(db, "file_nidx", content=String(indexme='no'))
  89     issue = module.IssueClass(db, "issue", title=String(indexme="yes"),
  90         status=Link("status"), nosy=Multilink("user"), deadline=Date(),
  91         foo=Interval(), files=Multilink("file"), assignedto=Link('user'),
  92         priority=Link('priority'), spam=Multilink('msg'),
  93         feedback=Link('msg'))
  94     stuff = module.Class(db, "stuff", stuff=String())
  95     session = module.Class(db, 'session', title=String())
  96     msg = module.FileClass(db, "msg", date=Date(),
  97                            author=Link("user", do_journal='no'),
  98                            files=Multilink('file'), inreplyto=String(),
  99                            messageid=String(),
 100                            recipients=Multilink("user", do_journal='no')
 101                            )
 102     session.disableJournalling()
 103     db.post_init()
 104     if create:
 105         user.create(username="admin", roles='Admin',
 106             password=password.Password('sekrit'))
 107         user.create(username="fred", roles='User',
 108             password=password.Password('sekrit'), address='fred@example.com')
 109         status.create(name="unread")
 110         status.create(name="in-progress")
 111         status.create(name="testing")
 112         status.create(name="resolved")
 113         priority.create(name="feature", order="2")
 114         priority.create(name="wish", order="3")
 115         priority.create(name="bug", order="1")
 116     db.commit()
 117
 118     # nosy tests require this
 119     db.security.addPermissionToRole('User', 'View', 'msg')
 120
 121 class MyTestCase(unittest.TestCase):
 122     def tearDown(self):
 123         if hasattr(self, 'db'):
 124             self.db.close()
 125         if os.path.exists(config.DATABASE):
 126             shutil.rmtree(config.DATABASE)
 127
 128     def open_database(self):
 129         self.db = self.module.Database(config, 'admin')
 130
 131
 132 if os.environ.has_key('LOGGING_LEVEL'):
 133     from roundup import rlog
 134     config.logging = rlog.BasicLogging()
 135     config.logging.setLevel(os.environ['LOGGING_LEVEL'])
 136     config.logging.getLogger('roundup.hyperdb').setFormat('%(message)s')
 137
 138 class commonDBTest(MyTestCase):
 139     def setUp(self):
 140         # remove previous test, ignore errors
 141         if os.path.exists(config.DATABASE):
 142             shutil.rmtree(config.DATABASE)
 143         os.makedirs(config.DATABASE + '/files')
 144         self.open_database()
 145         setupSchema(self.db, 1, self.module)
 146
 147     def iterSetup(self, classname='issue'):
 148         cls = getattr(self.db, classname)
 149         def filt_iter(*args):
 150             """ for checking equivalence of filter and filter_iter """
 151             return list(cls.filter_iter(*args))
 152         return self.assertEqual, cls.filter, filt_iter
 153
 154     def filteringSetupTransitiveSearch(self, classname='issue'):
 155         u_m = {}
 156         k = 30
 157         for user in (
 158                 {'username': 'ceo', 'age': 129},
 159                 {'username': 'grouplead1', 'age': 29, 'supervisor': '3'},
 160                 {'username': 'grouplead2', 'age': 29, 'supervisor': '3'},
 161                 {'username': 'worker1', 'age': 25, 'supervisor' : '4'},
 162                 {'username': 'worker2', 'age': 24, 'supervisor' : '4'},
 163                 {'username': 'worker3', 'age': 23, 'supervisor' : '5'},
 164                 {'username': 'worker4', 'age': 22, 'supervisor' : '5'},
 165                 {'username': 'worker5', 'age': 21, 'supervisor' : '5'}):
 166             u = self.db.user.create(**user)
 167             u_m [u] = self.db.msg.create(author = u, content = ' '
 168                 , date = date.Date ('2006-01-%s' % k))
 169             k -= 1
 170         i = date.Interval('-1d')
 171         for issue in (
 172                 {'title': 'ts1', 'status': '2', 'assignedto': '6',
 173                     'priority': '3', 'messages' : [u_m ['6']], 'nosy' : ['4']},
 174                 {'title': 'ts2', 'status': '1', 'assignedto': '6',
 175                     'priority': '3', 'messages' : [u_m ['6']], 'nosy' : ['5']},
 176                 {'title': 'ts4', 'status': '2', 'assignedto': '7',
 177                     'priority': '3', 'messages' : [u_m ['7']]},
 178                 {'title': 'ts5', 'status': '1', 'assignedto': '8',
 179                     'priority': '3', 'messages' : [u_m ['8']]},
 180                 {'title': 'ts6', 'status': '2', 'assignedto': '9',
 181                     'priority': '3', 'messages' : [u_m ['9']]},
 182                 {'title': 'ts7', 'status': '1', 'assignedto': '10',
 183                     'priority': '3', 'messages' : [u_m ['10']]},
 184                 {'title': 'ts8', 'status': '2', 'assignedto': '10',
 185                     'priority': '3', 'messages' : [u_m ['10']], 'foo' : i},
 186                 {'title': 'ts9', 'status': '1', 'assignedto': '10',
 187                     'priority': '3', 'messages' : [u_m ['10'], u_m ['9']]}):
 188             self.db.issue.create(**issue)
 189         return self.iterSetup(classname)
 190
 191
 192 class DBTest(commonDBTest):
 193
 194     def testRefresh(self):
 195         self.db.refresh_database()
 196
 197     #
 198     # automatic properties (well, the two easy ones anyway)
 199     #
 200     def testCreatorProperty(self):
 201         i = self.db.issue
 202         id1 = i.create(title='spam')
 203         self.db.journaltag = 'fred'
 204         id2 = i.create(title='spam')
 205         self.assertNotEqual(id1, id2)
 206         self.assertNotEqual(i.get(id1, 'creator'), i.get(id2, 'creator'))
 207
 208     def testActorProperty(self):
 209         i = self.db.issue
 210         id1 = i.create(title='spam')
 211         self.db.journaltag = 'fred'
 212         i.set(id1, title='asfasd')
 213         self.assertNotEqual(i.get(id1, 'creator'), i.get(id1, 'actor'))
 214
 215     # ID number controls
 216     def testIDGeneration(self):
 217         id1 = self.db.issue.create(title="spam", status='1')
 218         id2 = self.db.issue.create(title="eggs", status='2')
 219         self.assertNotEqual(id1, id2)
 220     def testIDSetting(self):
 221         # XXX numeric ids
 222         self.db.setid('issue', 10)
 223         id2 = self.db.issue.create(title="eggs", status='2')
 224         self.assertEqual('11', id2)
 225
 226     #
 227     # basic operations
 228     #
 229     def testEmptySet(self):
 230         id1 = self.db.issue.create(title="spam", status='1')
 231         self.db.issue.set(id1)
 232
 233     # String
 234     def testStringChange(self):
 235         for commit in (0,1):
 236             # test set & retrieve
 237             nid = self.db.issue.create(title="spam", status='1')
 238             self.assertEqual(self.db.issue.get(nid, 'title'), 'spam')
 239
 240             # change and make sure we retrieve the correct value
 241             self.db.issue.set(nid, title='eggs')
 242             if commit: self.db.commit()
 243             self.assertEqual(self.db.issue.get(nid, 'title'), 'eggs')
 244
 245     def testStringUnset(self):
 246         for commit in (0,1):
 247             nid = self.db.issue.create(title="spam", status='1')
 248             if commit: self.db.commit()
 249             self.assertEqual(self.db.issue.get(nid, 'title'), 'spam')
 250             # make sure we can unset
 251             self.db.issue.set(nid, title=None)
 252             if commit: self.db.commit()
 253             self.assertEqual(self.db.issue.get(nid, "title"), None)
 254
 255     # FileClass "content" property (no unset test)
 256     def testFileClassContentChange(self):
 257         for commit in (0,1):
 258             # test set & retrieve
 259             nid = self.db.file.create(content="spam")
 260             self.assertEqual(self.db.file.get(nid, 'content'), 'spam')
 261
 262             # change and make sure we retrieve the correct value
 263             self.db.file.set(nid, content='eggs')
 264             if commit: self.db.commit()
 265             self.assertEqual(self.db.file.get(nid, 'content'), 'eggs')
 266
 267     def testStringUnicode(self):
 268         # test set & retrieve
 269         ustr = u'\xe4\xf6\xfc\u20ac'.encode('utf8')
 270         nid = self.db.issue.create(title=ustr, status='1')
 271         self.assertEqual(self.db.issue.get(nid, 'title'), ustr)
 272
 273         # change and make sure we retrieve the correct value
 274         ustr2 = u'change \u20ac change'.encode('utf8')
 275         self.db.issue.set(nid, title=ustr2)
 276         self.db.commit()
 277         self.assertEqual(self.db.issue.get(nid, 'title'), ustr2)
 278
 279     # Link
 280     def testLinkChange(self):
 281         self.assertRaises(IndexError, self.db.issue.create, title="spam",
 282             status='100')
 283         for commit in (0,1):
 284             nid = self.db.issue.create(title="spam", status='1')
 285             if commit: self.db.commit()
 286             self.assertEqual(self.db.issue.get(nid, "status"), '1')
 287             self.db.issue.set(nid, status='2')
 288             if commit: self.db.commit()
 289             self.assertEqual(self.db.issue.get(nid, "status"), '2')
 290
 291     def testLinkUnset(self):
 292         for commit in (0,1):
 293             nid = self.db.issue.create(title="spam", status='1')
 294             if commit: self.db.commit()
 295             self.db.issue.set(nid, status=None)
 296             if commit: self.db.commit()
 297             self.assertEqual(self.db.issue.get(nid, "status"), None)
 298
 299     # Multilink
 300     def testMultilinkChange(self):
 301         for commit in (0,1):
 302             self.assertRaises(IndexError, self.db.issue.create, title="spam",
 303                 nosy=['foo%s'%commit])
 304             u1 = self.db.user.create(username='foo%s'%commit)
 305             u2 = self.db.user.create(username='bar%s'%commit)
 306             nid = self.db.issue.create(title="spam", nosy=[u1])
 307             if commit: self.db.commit()
 308             self.assertEqual(self.db.issue.get(nid, "nosy"), [u1])
 309             self.db.issue.set(nid, nosy=[])
 310             if commit: self.db.commit()
 311             self.assertEqual(self.db.issue.get(nid, "nosy"), [])
 312             self.db.issue.set(nid, nosy=[u1,u2])
 313             if commit: self.db.commit()
 314             l = [u1,u2]; l.sort()
 315             m = self.db.issue.get(nid, "nosy"); m.sort()
 316             self.assertEqual(l, m)
 317
 318             # verify that when we pass None to an Multilink it sets
 319             # it to an empty list
 320             self.db.issue.set(nid, nosy=None)
 321             if commit: self.db.commit()
 322             self.assertEqual(self.db.issue.get(nid, "nosy"), [])
 323
 324     def testMakeSeveralMultilinkedNodes(self):
 325         for commit in (0,1):
 326             u1 = self.db.user.create(username='foo%s'%commit)
 327             u2 = self.db.user.create(username='bar%s'%commit)
 328             u3 = self.db.user.create(username='baz%s'%commit)
 329             nid = self.db.issue.create(title="spam", nosy=[u1])
 330             if commit: self.db.commit()
 331             self.assertEqual(self.db.issue.get(nid, "nosy"), [u1])
 332             self.db.issue.set(nid, deadline=date.Date('.'))
 333             self.db.issue.set(nid, nosy=[u1,u2], title='ta%s'%commit)
 334             if commit: self.db.commit()
 335             self.assertEqual(self.db.issue.get(nid, "nosy"), [u1,u2])
 336             self.db.issue.set(nid, deadline=date.Date('.'))
 337             self.db.issue.set(nid, nosy=[u1,u2,u3], title='tb%s'%commit)
 338             if commit: self.db.commit()
 339             self.assertEqual(self.db.issue.get(nid, "nosy"), [u1,u2,u3])
 340
 341     def testMultilinkChangeIterable(self):
 342         for commit in (0,1):
 343             # invalid nosy value assertion
 344             self.assertRaises(IndexError, self.db.issue.create, title='spam',
 345                 nosy=['foo%s'%commit])
 346             # invalid type for nosy create
 347             self.assertRaises(TypeError, self.db.issue.create, title='spam',
 348                 nosy=1)
 349             u1 = self.db.user.create(username='foo%s'%commit)
 350             u2 = self.db.user.create(username='bar%s'%commit)
 351             # try a couple of the built-in iterable types to make
 352             # sure that we accept them and handle them properly
 353             # try a set as input for the multilink
 354             nid = self.db.issue.create(title="spam", nosy=set(u1))
 355             if commit: self.db.commit()
 356             self.assertEqual(self.db.issue.get(nid, "nosy"), [u1])
 357             self.assertRaises(TypeError, self.db.issue.set, nid,
 358                 nosy='invalid type')
 359             # test with a tuple
 360             self.db.issue.set(nid, nosy=tuple())
 361             if commit: self.db.commit()
 362             self.assertEqual(self.db.issue.get(nid, "nosy"), [])
 363             # make sure we accept a frozen set
 364             self.db.issue.set(nid, nosy=set([u1,u2]))
 365             if commit: self.db.commit()
 366             l = [u1,u2]; l.sort()
 367             m = self.db.issue.get(nid, "nosy"); m.sort()
 368             self.assertEqual(l, m)
 369
 370
 371 # XXX one day, maybe...
 372 #    def testMultilinkOrdering(self):
 373 #        for i in range(10):
 374 #            self.db.user.create(username='foo%s'%i)
 375 #        i = self.db.issue.create(title="spam", nosy=['5','3','12','4'])
 376 #        self.db.commit()
 377 #        l = self.db.issue.get(i, "nosy")
 378 #        # all backends should return the Multilink numeric-id-sorted
 379 #        self.assertEqual(l, ['3', '4', '5', '12'])
 380
 381     # Date
 382     def testDateChange(self):
 383         self.assertRaises(TypeError, self.db.issue.create,
 384             title='spam', deadline=1)
 385         for commit in (0,1):
 386             nid = self.db.issue.create(title="spam", status='1')
 387             self.assertRaises(TypeError, self.db.issue.set, nid, deadline=1)
 388             a = self.db.issue.get(nid, "deadline")
 389             if commit: self.db.commit()
 390             self.db.issue.set(nid, deadline=date.Date())
 391             b = self.db.issue.get(nid, "deadline")
 392             if commit: self.db.commit()
 393             self.assertNotEqual(a, b)
 394             self.assertNotEqual(b, date.Date('1970-1-1.00:00:00'))
 395             # The 1970 date will fail for metakit -- it is used
 396             # internally for storing NULL. The others would, too
 397             # because metakit tries to convert date.timestamp to an int
 398             # for storing and fails with an overflow.
 399             for d in [date.Date (x) for x in '2038', '1970', '0033', '9999']:
 400                 self.db.issue.set(nid, deadline=d)
 401                 if commit: self.db.commit()
 402                 c = self.db.issue.get(nid, "deadline")
 403                 self.assertEqual(c, d)
 404
 405     def testDateLeapYear(self):
 406         nid = self.db.issue.create(title='spam', status='1',
 407             deadline=date.Date('2008-02-29'))
 408         self.assertEquals(str(self.db.issue.get(nid, 'deadline')),
 409             '2008-02-29.00:00:00')
 410         self.assertEquals(self.db.issue.filter(None,
 411             {'deadline': '2008-02-29'}), [nid])
 412         self.assertEquals(list(self.db.issue.filter_iter(None,
 413             {'deadline': '2008-02-29'})), [nid])
 414         self.db.issue.set(nid, deadline=date.Date('2008-03-01'))
 415         self.assertEquals(str(self.db.issue.get(nid, 'deadline')),
 416             '2008-03-01.00:00:00')
 417         self.assertEquals(self.db.issue.filter(None,
 418             {'deadline': '2008-02-29'}), [])
 419         self.assertEquals(list(self.db.issue.filter_iter(None,
 420             {'deadline': '2008-02-29'})), [])
 421
 422     def testDateUnset(self):
 423         for commit in (0,1):
 424             nid = self.db.issue.create(title="spam", status='1')
 425             self.db.issue.set(nid, deadline=date.Date())
 426             if commit: self.db.commit()
 427             self.assertNotEqual(self.db.issue.get(nid, "deadline"), None)
 428             self.db.issue.set(nid, deadline=None)
 429             if commit: self.db.commit()
 430             self.assertEqual(self.db.issue.get(nid, "deadline"), None)
 431
 432     # Interval
 433     def testIntervalChange(self):
 434         self.assertRaises(TypeError, self.db.issue.create,
 435             title='spam', foo=1)
 436         for commit in (0,1):
 437             nid = self.db.issue.create(title="spam", status='1')
 438             self.assertRaises(TypeError, self.db.issue.set, nid, foo=1)
 439             if commit: self.db.commit()
 440             a = self.db.issue.get(nid, "foo")
 441             i = date.Interval('-1d')
 442             self.db.issue.set(nid, foo=i)
 443             if commit: self.db.commit()
 444             self.assertNotEqual(self.db.issue.get(nid, "foo"), a)
 445             self.assertEqual(i, self.db.issue.get(nid, "foo"))
 446             j = date.Interval('1y')
 447             self.db.issue.set(nid, foo=j)
 448             if commit: self.db.commit()
 449             self.assertNotEqual(self.db.issue.get(nid, "foo"), i)
 450             self.assertEqual(j, self.db.issue.get(nid, "foo"))
 451
 452     def testIntervalUnset(self):
 453         for commit in (0,1):
 454             nid = self.db.issue.create(title="spam", status='1')
 455             self.db.issue.set(nid, foo=date.Interval('-1d'))
 456             if commit: self.db.commit()
 457             self.assertNotEqual(self.db.issue.get(nid, "foo"), None)
 458             self.db.issue.set(nid, foo=None)
 459             if commit: self.db.commit()
 460             self.assertEqual(self.db.issue.get(nid, "foo"), None)
 461
 462     # Boolean
 463     def testBooleanSet(self):
 464         nid = self.db.user.create(username='one', assignable=1)
 465         self.assertEqual(self.db.user.get(nid, "assignable"), 1)
 466         nid = self.db.user.create(username='two', assignable=0)
 467         self.assertEqual(self.db.user.get(nid, "assignable"), 0)
 468
 469     def testBooleanChange(self):
 470         userid = self.db.user.create(username='foo', assignable=1)
 471         self.assertEqual(1, self.db.user.get(userid, 'assignable'))
 472         self.db.user.set(userid, assignable=0)
 473         self.assertEqual(self.db.user.get(userid, 'assignable'), 0)
 474         self.db.user.set(userid, assignable=1)
 475         self.assertEqual(self.db.user.get(userid, 'assignable'), 1)
 476
 477     def testBooleanUnset(self):
 478         nid = self.db.user.create(username='foo', assignable=1)
 479         self.db.user.set(nid, assignable=None)
 480         self.assertEqual(self.db.user.get(nid, "assignable"), None)
 481
 482     # Number
 483     def testNumberChange(self):
 484         nid = self.db.user.create(username='foo', age=1)
 485         self.assertEqual(1, self.db.user.get(nid, 'age'))
 486         self.db.user.set(nid, age=3)
 487         self.assertNotEqual(self.db.user.get(nid, 'age'), 1)
 488         self.db.user.set(nid, age=1.0)
 489         self.assertEqual(self.db.user.get(nid, 'age'), 1)
 490         self.db.user.set(nid, age=0)
 491         self.assertEqual(self.db.user.get(nid, 'age'), 0)
 492
 493         nid = self.db.user.create(username='bar', age=0)
 494         self.assertEqual(self.db.user.get(nid, 'age'), 0)
 495
 496     def testNumberUnset(self):
 497         nid = self.db.user.create(username='foo', age=1)
 498         self.db.user.set(nid, age=None)
 499         self.assertEqual(self.db.user.get(nid, "age"), None)
 500
 501     # Password
 502     def testPasswordChange(self):
 503         x = password.Password('x')
 504         userid = self.db.user.create(username='foo', password=x)
 505         self.assertEqual(x, self.db.user.get(userid, 'password'))
 506         self.assertEqual(self.db.user.get(userid, 'password'), 'x')
 507         y = password.Password('y')
 508         self.db.user.set(userid, password=y)
 509         self.assertEqual(self.db.user.get(userid, 'password'), 'y')
 510         self.assertRaises(TypeError, self.db.user.create, userid,
 511             username='bar', password='x')
 512         self.assertRaises(TypeError, self.db.user.set, userid, password='x')
 513
 514     def testPasswordUnset(self):
 515         x = password.Password('x')
 516         nid = self.db.user.create(username='foo', password=x)
 517         self.db.user.set(nid, assignable=None)
 518         self.assertEqual(self.db.user.get(nid, "assignable"), None)
 519
 520     # key value
 521     def testKeyValue(self):
 522         self.assertRaises(ValueError, self.db.user.create)
 523
 524         newid = self.db.user.create(username="spam")
 525         self.assertEqual(self.db.user.lookup('spam'), newid)
 526         self.db.commit()
 527         self.assertEqual(self.db.user.lookup('spam'), newid)
 528         self.db.user.retire(newid)
 529         self.assertRaises(KeyError, self.db.user.lookup, 'spam')
 530
 531         # use the key again now that the old is retired
 532         newid2 = self.db.user.create(username="spam")
 533         self.assertNotEqual(newid, newid2)
 534         # try to restore old node. this shouldn't succeed!
 535         self.assertRaises(KeyError, self.db.user.restore, newid)
 536
 537         self.assertRaises(TypeError, self.db.issue.lookup, 'fubar')
 538
 539     # label property
 540     def testLabelProp(self):
 541         # key prop
 542         self.assertEqual(self.db.status.labelprop(), 'name')
 543         self.assertEqual(self.db.user.labelprop(), 'username')
 544         # title
 545         self.assertEqual(self.db.issue.labelprop(), 'title')
 546         # name
 547         self.assertEqual(self.db.file.labelprop(), 'name')
 548         # id
 549         self.assertEqual(self.db.stuff.labelprop(default_to_id=1), 'id')
 550
 551     # retirement
 552     def testRetire(self):
 553         self.db.issue.create(title="spam", status='1')
 554         b = self.db.status.get('1', 'name')
 555         a = self.db.status.list()
 556         nodeids = self.db.status.getnodeids()
 557         self.db.status.retire('1')
 558         others = nodeids[:]
 559         others.remove('1')
 560
 561         self.assertEqual(set(self.db.status.getnodeids()),
 562             set(nodeids))
 563         self.assertEqual(set(self.db.status.getnodeids(retired=True)),
 564             set(['1']))
 565         self.assertEqual(set(self.db.status.getnodeids(retired=False)),
 566             set(others))
 567
 568         self.assert_(self.db.status.is_retired('1'))
 569
 570         # make sure the list is different
 571         self.assertNotEqual(a, self.db.status.list())
 572
 573         # can still access the node if necessary
 574         self.assertEqual(self.db.status.get('1', 'name'), b)
 575         self.assertRaises(IndexError, self.db.status.set, '1', name='hello')
 576         self.db.commit()
 577         self.assert_(self.db.status.is_retired('1'))
 578         self.assertEqual(self.db.status.get('1', 'name'), b)
 579         self.assertNotEqual(a, self.db.status.list())
 580
 581         # try to restore retired node
 582         self.db.status.restore('1')
 583
 584         self.assert_(not self.db.status.is_retired('1'))
 585
 586     def testCacheCreateSet(self):
 587         self.db.issue.create(title="spam", status='1')
 588         a = self.db.issue.get('1', 'title')
 589         self.assertEqual(a, 'spam')
 590         self.db.issue.set('1', title='ham')
 591         b = self.db.issue.get('1', 'title')
 592         self.assertEqual(b, 'ham')
 593
 594     def testSerialisation(self):
 595         nid = self.db.issue.create(title="spam", status='1',
 596             deadline=date.Date(), foo=date.Interval('-1d'))
 597         self.db.commit()
 598         assert isinstance(self.db.issue.get(nid, 'deadline'), date.Date)
 599         assert isinstance(self.db.issue.get(nid, 'foo'), date.Interval)
 600         uid = self.db.user.create(username="fozzy",
 601             password=password.Password('t. bear'))
 602         self.db.commit()
 603         assert isinstance(self.db.user.get(uid, 'password'), password.Password)
 604
 605     def testTransactions(self):
 606         # remember the number of items we started
 607         num_issues = len(self.db.issue.list())
 608         num_files = self.db.numfiles()
 609         self.db.issue.create(title="don't commit me!", status='1')
 610         self.assertNotEqual(num_issues, len(self.db.issue.list()))
 611         self.db.rollback()
 612         self.assertEqual(num_issues, len(self.db.issue.list()))
 613         self.db.issue.create(title="please commit me!", status='1')
 614         self.assertNotEqual(num_issues, len(self.db.issue.list()))
 615         self.db.commit()
 616         self.assertNotEqual(num_issues, len(self.db.issue.list()))
 617         self.db.rollback()
 618         self.assertNotEqual(num_issues, len(self.db.issue.list()))
 619         self.db.file.create(name="test", type="text/plain", content="hi")
 620         self.db.rollback()
 621         self.assertEqual(num_files, self.db.numfiles())
 622         for i in range(10):
 623             self.db.file.create(name="test", type="text/plain",
 624                     content="hi %d"%(i))
 625             self.db.commit()
 626         num_files2 = self.db.numfiles()
 627         self.assertNotEqual(num_files, num_files2)
 628         self.db.file.create(name="test", type="text/plain", content="hi")
 629         self.db.rollback()
 630         self.assertNotEqual(num_files, self.db.numfiles())
 631         self.assertEqual(num_files2, self.db.numfiles())
 632
 633         # rollback / cache interaction
 634         name1 = self.db.user.get('1', 'username')
 635         self.db.user.set('1', username = name1+name1)
 636         # get the prop so the info's forced into the cache (if there is one)
 637         self.db.user.get('1', 'username')
 638         self.db.rollback()
 639         name2 = self.db.user.get('1', 'username')
 640         self.assertEqual(name1, name2)
 641
 642     def testDestroyBlob(self):
 643         # destroy an uncommitted blob
 644         f1 = self.db.file.create(content='hello', type="text/plain")
 645         self.db.commit()
 646         fn = self.db.filename('file', f1)
 647         self.db.file.destroy(f1)
 648         self.db.commit()
 649         self.assertEqual(os.path.exists(fn), False)
 650
 651     def testDestroyNoJournalling(self):
 652         self.innerTestDestroy(klass=self.db.session)
 653
 654     def testDestroyJournalling(self):
 655         self.innerTestDestroy(klass=self.db.issue)
 656
 657     def innerTestDestroy(self, klass):
 658         newid = klass.create(title='Mr Friendly')
 659         n = len(klass.list())
 660         self.assertEqual(klass.get(newid, 'title'), 'Mr Friendly')
 661         count = klass.count()
 662         klass.destroy(newid)
 663         self.assertNotEqual(count, klass.count())
 664         self.assertRaises(IndexError, klass.get, newid, 'title')
 665         self.assertNotEqual(len(klass.list()), n)
 666         if klass.do_journal:
 667             self.assertRaises(IndexError, klass.history, newid)
 668
 669         # now with a commit
 670         newid = klass.create(title='Mr Friendly')
 671         n = len(klass.list())
 672         self.assertEqual(klass.get(newid, 'title'), 'Mr Friendly')
 673         self.db.commit()
 674         count = klass.count()
 675         klass.destroy(newid)
 676         self.assertNotEqual(count, klass.count())
 677         self.assertRaises(IndexError, klass.get, newid, 'title')
 678         self.db.commit()
 679         self.assertRaises(IndexError, klass.get, newid, 'title')
 680         self.assertNotEqual(len(klass.list()), n)
 681         if klass.do_journal:
 682             self.assertRaises(IndexError, klass.history, newid)
 683
 684         # now with a rollback
 685         newid = klass.create(title='Mr Friendly')
 686         n = len(klass.list())
 687         self.assertEqual(klass.get(newid, 'title'), 'Mr Friendly')
 688         self.db.commit()
 689         count = klass.count()
 690         klass.destroy(newid)
 691         self.assertNotEqual(len(klass.list()), n)
 692         self.assertRaises(IndexError, klass.get, newid, 'title')
 693         self.db.rollback()
 694         self.assertEqual(count, klass.count())
 695         self.assertEqual(klass.get(newid, 'title'), 'Mr Friendly')
 696         self.assertEqual(len(klass.list()), n)
 697         if klass.do_journal:
 698             self.assertNotEqual(klass.history(newid), [])
 699
 700     def testExceptions(self):
 701         # this tests the exceptions that should be raised
 702         ar = self.assertRaises
 703
 704         ar(KeyError, self.db.getclass, 'fubar')
 705
 706         #
 707         # class create
 708         #
 709         # string property
 710         ar(TypeError, self.db.status.create, name=1)
 711         # id, creation, creator and activity properties are reserved
 712         ar(KeyError, self.db.status.create, id=1)
 713         ar(KeyError, self.db.status.create, creation=1)
 714         ar(KeyError, self.db.status.create, creator=1)
 715         ar(KeyError, self.db.status.create, activity=1)
 716         ar(KeyError, self.db.status.create, actor=1)
 717         # invalid property name
 718         ar(KeyError, self.db.status.create, foo='foo')
 719         # key name clash
 720         ar(ValueError, self.db.status.create, name='unread')
 721         # invalid link index
 722         ar(IndexError, self.db.issue.create, title='foo', status='bar')
 723         # invalid link value
 724         ar(ValueError, self.db.issue.create, title='foo', status=1)
 725         # invalid multilink type
 726         ar(TypeError, self.db.issue.create, title='foo', status='1',
 727             nosy='hello')
 728         # invalid multilink index type
 729         ar(ValueError, self.db.issue.create, title='foo', status='1',
 730             nosy=[1])
 731         # invalid multilink index
 732         ar(IndexError, self.db.issue.create, title='foo', status='1',
 733             nosy=['10'])
 734
 735         #
 736         # key property
 737         #
 738         # key must be a String
 739         ar(TypeError, self.db.file.setkey, 'fooz')
 740         # key must exist
 741         ar(KeyError, self.db.file.setkey, 'fubar')
 742
 743         #
 744         # class get
 745         #
 746         # invalid node id
 747         ar(IndexError, self.db.issue.get, '99', 'title')
 748         # invalid property name
 749         ar(KeyError, self.db.status.get, '2', 'foo')
 750
 751         #
 752         # class set
 753         #
 754         # invalid node id
 755         ar(IndexError, self.db.issue.set, '99', title='foo')
 756         # invalid property name
 757         ar(KeyError, self.db.status.set, '1', foo='foo')
 758         # string property
 759         ar(TypeError, self.db.status.set, '1', name=1)
 760         # key name clash
 761         ar(ValueError, self.db.status.set, '2', name='unread')
 762         # set up a valid issue for me to work on
 763         id = self.db.issue.create(title="spam", status='1')
 764         # invalid link index
 765         ar(IndexError, self.db.issue.set, id, title='foo', status='bar')
 766         # invalid link value
 767         ar(ValueError, self.db.issue.set, id, title='foo', status=1)
 768         # invalid multilink type
 769         ar(TypeError, self.db.issue.set, id, title='foo', status='1',
 770             nosy='hello')
 771         # invalid multilink index type
 772         ar(ValueError, self.db.issue.set, id, title='foo', status='1',
 773             nosy=[1])
 774         # invalid multilink index
 775         ar(IndexError, self.db.issue.set, id, title='foo', status='1',
 776             nosy=['10'])
 777         # NOTE: the following increment the username to avoid problems
 778         # within metakit's backend (it creates the node, and then sets the
 779         # info, so the create (and by a fluke the username set) go through
 780         # before the age/assignable/etc. set, which raises the exception)
 781         # invalid number value
 782         ar(TypeError, self.db.user.create, username='foo', age='a')
 783         # invalid boolean value
 784         ar(TypeError, self.db.user.create, username='foo2', assignable='true')
 785         nid = self.db.user.create(username='foo3')
 786         # invalid number value
 787         ar(TypeError, self.db.user.set, nid, age='a')
 788         # invalid boolean value
 789         ar(TypeError, self.db.user.set, nid, assignable='true')
 790
 791     def testAuditors(self):
 792         class test:
 793             called = False
 794             def call(self, *args): self.called = True
 795         create = test()
 796
 797         self.db.user.audit('create', create.call)
 798         self.db.user.create(username="mary")
 799         self.assertEqual(create.called, True)
 800
 801         set = test()
 802         self.db.user.audit('set', set.call)
 803         self.db.user.set('1', username="joe")
 804         self.assertEqual(set.called, True)
 805
 806         retire = test()
 807         self.db.user.audit('retire', retire.call)
 808         self.db.user.retire('1')
 809         self.assertEqual(retire.called, True)
 810
 811     def testAuditorTwo(self):
 812         class test:
 813             n = 0
 814             def a(self, *args): self.call_a = self.n; self.n += 1
 815             def b(self, *args): self.call_b = self.n; self.n += 1
 816             def c(self, *args): self.call_c = self.n; self.n += 1
 817         test = test()
 818         self.db.user.audit('create', test.b, 1)
 819         self.db.user.audit('create', test.a, 1)
 820         self.db.user.audit('create', test.c, 2)
 821         self.db.user.create(username="mary")
 822         self.assertEqual(test.call_a, 0)
 823         self.assertEqual(test.call_b, 1)
 824         self.assertEqual(test.call_c, 2)
 825
 826     def testJournals(self):
 827         muid = self.db.user.create(username="mary")
 828         self.db.user.create(username="pete")
 829         self.db.issue.create(title="spam", status='1')
 830         self.db.commit()
 831
 832         # journal entry for issue create
 833         journal = self.db.getjournal('issue', '1')
 834         self.assertEqual(1, len(journal))
 835         (nodeid, date_stamp, journaltag, action, params) = journal[0]
 836         self.assertEqual(nodeid, '1')
 837         self.assertEqual(journaltag, self.db.user.lookup('admin'))
 838         self.assertEqual(action, 'create')
 839         keys = params.keys()
 840         keys.sort()
 841         self.assertEqual(keys, [])
 842
 843         # journal entry for link
 844         journal = self.db.getjournal('user', '1')
 845         self.assertEqual(1, len(journal))
 846         self.db.issue.set('1', assignedto='1')
 847         self.db.commit()
 848         journal = self.db.getjournal('user', '1')
 849         self.assertEqual(2, len(journal))
 850         (nodeid, date_stamp, journaltag, action, params) = journal[1]
 851         self.assertEqual('1', nodeid)
 852         self.assertEqual('1', journaltag)
 853         self.assertEqual('link', action)
 854         self.assertEqual(('issue', '1', 'assignedto'), params)
 855
 856         # wait a bit to keep proper order of journal entries
 857         time.sleep(0.01)
 858         # journal entry for unlink
 859         self.db.setCurrentUser('mary')
 860         self.db.issue.set('1', assignedto='2')
 861         self.db.commit()
 862         journal = self.db.getjournal('user', '1')
 863         self.assertEqual(3, len(journal))
 864         (nodeid, date_stamp, journaltag, action, params) = journal[2]
 865         self.assertEqual('1', nodeid)
 866         self.assertEqual(muid, journaltag)
 867         self.assertEqual('unlink', action)
 868         self.assertEqual(('issue', '1', 'assignedto'), params)
 869
 870         # test disabling journalling
 871         # ... get the last entry
 872         jlen = len(self.db.getjournal('user', '1'))
 873         self.db.issue.disableJournalling()
 874         self.db.issue.set('1', title='hello world')
 875         self.db.commit()
 876         # see if the change was journalled when it shouldn't have been
 877         self.assertEqual(jlen,  len(self.db.getjournal('user', '1')))
 878         jlen = len(self.db.getjournal('issue', '1'))
 879         self.db.issue.enableJournalling()
 880         self.db.issue.set('1', title='hello world 2')
 881         self.db.commit()
 882         # see if the change was journalled
 883         self.assertNotEqual(jlen,  len(self.db.getjournal('issue', '1')))
 884
 885     def testJournalPreCommit(self):
 886         id = self.db.user.create(username="mary")
 887         self.assertEqual(len(self.db.getjournal('user', id)), 1)
 888         self.db.commit()
 889
 890     def testPack(self):
 891         id = self.db.issue.create(title="spam", status='1')
 892         self.db.commit()
 893         time.sleep(1)
 894         self.db.issue.set(id, status='2')
 895         self.db.commit()
 896
 897         # sleep for at least a second, then get a date to pack at
 898         time.sleep(1)
 899         pack_before = date.Date('.')
 900
 901         # wait another second and add one more entry
 902         time.sleep(1)
 903         self.db.issue.set(id, status='3')
 904         self.db.commit()
 905         jlen = len(self.db.getjournal('issue', id))
 906
 907         # pack
 908         self.db.pack(pack_before)
 909
 910         # we should have the create and last set entries now
 911         self.assertEqual(jlen-1, len(self.db.getjournal('issue', id)))
 912
 913     def testIndexerSearching(self):
 914         f1 = self.db.file.create(content='hello', type="text/plain")
 915         # content='world' has the wrong content-type and won't be indexed
 916         f2 = self.db.file.create(content='world', type="text/frozz",
 917             comment='blah blah')
 918         i1 = self.db.issue.create(files=[f1, f2], title="flebble plop")
 919         i2 = self.db.issue.create(title="flebble the frooz")
 920         self.db.commit()
 921         self.assertEquals(self.db.indexer.search([], self.db.issue), {})
 922         self.assertEquals(self.db.indexer.search(['hello'], self.db.issue),
 923             {i1: {'files': [f1]}})
 924         # content='world' has the wrong content-type and shouldn't be indexed
 925         self.assertEquals(self.db.indexer.search(['world'], self.db.issue), {})
 926         self.assertEquals(self.db.indexer.search(['frooz'], self.db.issue),
 927             {i2: {}})
 928         self.assertEquals(self.db.indexer.search(['flebble'], self.db.issue),
 929             {i1: {}, i2: {}})
 930
 931         # test AND'ing of search terms
 932         self.assertEquals(self.db.indexer.search(['frooz', 'flebble'],
 933             self.db.issue), {i2: {}})
 934
 935         # unindexed stopword
 936         self.assertEquals(self.db.indexer.search(['the'], self.db.issue), {})
 937
 938     def testIndexerSearchingLink(self):
 939         m1 = self.db.msg.create(content="one two")
 940         i1 = self.db.issue.create(messages=[m1])
 941         m2 = self.db.msg.create(content="two three")
 942         i2 = self.db.issue.create(feedback=m2)
 943         self.db.commit()
 944         self.assertEquals(self.db.indexer.search(['two'], self.db.issue),
 945             {i1: {'messages': [m1]}, i2: {'feedback': [m2]}})
 946
 947     def testIndexerSearchMulti(self):
 948         m1 = self.db.msg.create(content="one two")
 949         m2 = self.db.msg.create(content="two three")
 950         i1 = self.db.issue.create(messages=[m1])
 951         i2 = self.db.issue.create(spam=[m2])
 952         self.db.commit()
 953         self.assertEquals(self.db.indexer.search([], self.db.issue), {})
 954         self.assertEquals(self.db.indexer.search(['one'], self.db.issue),
 955             {i1: {'messages': [m1]}})
 956         self.assertEquals(self.db.indexer.search(['two'], self.db.issue),
 957             {i1: {'messages': [m1]}, i2: {'spam': [m2]}})
 958         self.assertEquals(self.db.indexer.search(['three'], self.db.issue),
 959             {i2: {'spam': [m2]}})
 960
 961     def testReindexingChange(self):
 962         search = self.db.indexer.search
 963         issue = self.db.issue
 964         i1 = issue.create(title="flebble plop")
 965         i2 = issue.create(title="flebble frooz")
 966         self.db.commit()
 967         self.assertEquals(search(['plop'], issue), {i1: {}})
 968         self.assertEquals(search(['flebble'], issue), {i1: {}, i2: {}})
 969
 970         # change i1's title
 971         issue.set(i1, title="plop")
 972         self.db.commit()
 973         self.assertEquals(search(['plop'], issue), {i1: {}})
 974         self.assertEquals(search(['flebble'], issue), {i2: {}})
 975
 976     def testReindexingClear(self):
 977         search = self.db.indexer.search
 978         issue = self.db.issue
 979         i1 = issue.create(title="flebble plop")
 980         i2 = issue.create(title="flebble frooz")
 981         self.db.commit()
 982         self.assertEquals(search(['plop'], issue), {i1: {}})
 983         self.assertEquals(search(['flebble'], issue), {i1: {}, i2: {}})
 984
 985         # unset i1's title
 986         issue.set(i1, title="")
 987         self.db.commit()
 988         self.assertEquals(search(['plop'], issue), {})
 989         self.assertEquals(search(['flebble'], issue), {i2: {}})
 990
 991     def testFileClassReindexing(self):
 992         f1 = self.db.file.create(content='hello')
 993         f2 = self.db.file.create(content='hello, world')
 994         i1 = self.db.issue.create(files=[f1, f2])
 995         self.db.commit()
 996         d = self.db.indexer.search(['hello'], self.db.issue)
 997         self.assert_(d.has_key(i1))
 998         d[i1]['files'].sort()
 999         self.assertEquals(d, {i1: {'files': [f1, f2]}})
1000         self.assertEquals(self.db.indexer.search(['world'], self.db.issue),
1001             {i1: {'files': [f2]}})
1002         self.db.file.set(f1, content="world")
1003         self.db.commit()
1004         d = self.db.indexer.search(['world'], self.db.issue)
1005         d[i1]['files'].sort()
1006         self.assertEquals(d, {i1: {'files': [f1, f2]}})
1007         self.assertEquals(self.db.indexer.search(['hello'], self.db.issue),
1008             {i1: {'files': [f2]}})
1009
1010     def testFileClassIndexingNoNoNo(self):
1011         f1 = self.db.file.create(content='hello')
1012         self.db.commit()
1013         self.assertEquals(self.db.indexer.search(['hello'], self.db.file),
1014             {'1': {}})
1015
1016         f1 = self.db.file_nidx.create(content='hello')
1017         self.db.commit()
1018         self.assertEquals(self.db.indexer.search(['hello'], self.db.file_nidx),
1019             {})
1020
1021     def testForcedReindexing(self):
1022         self.db.issue.create(title="flebble frooz")
1023         self.db.commit()
1024         self.assertEquals(self.db.indexer.search(['flebble'], self.db.issue),
1025             {'1': {}})
1026         self.db.indexer.quiet = 1
1027         self.db.indexer.force_reindex()
1028         self.db.post_init()
1029         self.db.indexer.quiet = 9
1030         self.assertEquals(self.db.indexer.search(['flebble'], self.db.issue),
1031             {'1': {}})
1032
1033     def testIndexingPropertiesOnImport(self):
1034         # import an issue
1035         title = 'Bzzt'
1036         nodeid = self.db.issue.import_list(['title', 'messages', 'files',
1037             'spam', 'nosy', 'superseder'], [repr(title), '[]', '[]',
1038             '[]', '[]', '[]'])
1039         self.db.commit()
1040
1041         # Content of title attribute is indexed
1042         self.assertEquals(self.db.indexer.search([title], self.db.issue),
1043             {str(nodeid):{}})
1044
1045
1046     #
1047     # searching tests follow
1048     #
1049     def testFindIncorrectProperty(self):
1050         self.assertRaises(TypeError, self.db.issue.find, title='fubar')
1051
1052     def _find_test_setup(self):
1053         self.db.file.create(content='')
1054         self.db.file.create(content='')
1055         self.db.user.create(username='')
1056         one = self.db.issue.create(status="1", nosy=['1'])
1057         two = self.db.issue.create(status="2", nosy=['2'], files=['1'],
1058             assignedto='2')
1059         three = self.db.issue.create(status="1", nosy=['1','2'])
1060         four = self.db.issue.create(status="3", assignedto='1',
1061             files=['1','2'])
1062         return one, two, three, four
1063
1064     def testFindLink(self):
1065         one, two, three, four = self._find_test_setup()
1066         got = self.db.issue.find(status='1')
1067         got.sort()
1068         self.assertEqual(got, [one, three])
1069         got = self.db.issue.find(status={'1':1})
1070         got.sort()
1071         self.assertEqual(got, [one, three])
1072
1073     def testFindLinkFail(self):
1074         self._find_test_setup()
1075         self.assertEqual(self.db.issue.find(status='4'), [])
1076         self.assertEqual(self.db.issue.find(status={'4':1}), [])
1077
1078     def testFindLinkUnset(self):
1079         one, two, three, four = self._find_test_setup()
1080         got = self.db.issue.find(assignedto=None)
1081         got.sort()
1082         self.assertEqual(got, [one, three])
1083         got = self.db.issue.find(assignedto={None:1})
1084         got.sort()
1085         self.assertEqual(got, [one, three])
1086
1087     def testFindMultipleLink(self):
1088         one, two, three, four = self._find_test_setup()
1089         l = self.db.issue.find(status={'1':1, '3':1})
1090         l.sort()
1091         self.assertEqual(l, [one, three, four])
1092         l = self.db.issue.find(assignedto={None:1, '1':1})
1093         l.sort()
1094         self.assertEqual(l, [one, three, four])
1095
1096     def testFindMultilink(self):
1097         one, two, three, four = self._find_test_setup()
1098         got = self.db.issue.find(nosy='2')
1099         got.sort()
1100         self.assertEqual(got, [two, three])
1101         got = self.db.issue.find(nosy={'2':1})
1102         got.sort()
1103         self.assertEqual(got, [two, three])
1104         got = self.db.issue.find(nosy={'2':1}, files={})
1105         got.sort()
1106         self.assertEqual(got, [two, three])
1107
1108     def testFindMultiMultilink(self):
1109         one, two, three, four = self._find_test_setup()
1110         got = self.db.issue.find(nosy='2', files='1')
1111         got.sort()
1112         self.assertEqual(got, [two, three, four])
1113         got = self.db.issue.find(nosy={'2':1}, files={'1':1})
1114         got.sort()
1115         self.assertEqual(got, [two, three, four])
1116
1117     def testFindMultilinkFail(self):
1118         self._find_test_setup()
1119         self.assertEqual(self.db.issue.find(nosy='3'), [])
1120         self.assertEqual(self.db.issue.find(nosy={'3':1}), [])
1121
1122     def testFindMultilinkUnset(self):
1123         self._find_test_setup()
1124         self.assertEqual(self.db.issue.find(nosy={}), [])
1125
1126     def testFindLinkAndMultilink(self):
1127         one, two, three, four = self._find_test_setup()
1128         got = self.db.issue.find(status='1', nosy='2')
1129         got.sort()
1130         self.assertEqual(got, [one, two, three])
1131         got = self.db.issue.find(status={'1':1}, nosy={'2':1})
1132         got.sort()
1133         self.assertEqual(got, [one, two, three])
1134
1135     def testFindRetired(self):
1136         one, two, three, four = self._find_test_setup()
1137         self.assertEqual(len(self.db.issue.find(status='1')), 2)
1138         self.db.issue.retire(one)
1139         self.assertEqual(len(self.db.issue.find(status='1')), 1)
1140
1141     def testStringFind(self):
1142         self.assertRaises(TypeError, self.db.issue.stringFind, status='1')
1143
1144         ids = []
1145         ids.append(self.db.issue.create(title="spam"))
1146         self.db.issue.create(title="not spam")
1147         ids.append(self.db.issue.create(title="spam"))
1148         ids.sort()
1149         got = self.db.issue.stringFind(title='spam')
1150         got.sort()
1151         self.assertEqual(got, ids)
1152         self.assertEqual(self.db.issue.stringFind(title='fubar'), [])
1153
1154         # test retiring a node
1155         self.db.issue.retire(ids[0])
1156         self.assertEqual(len(self.db.issue.stringFind(title='spam')), 1)
1157
1158     def filteringSetup(self, classname='issue'):
1159         for user in (
1160                 {'username': 'bleep', 'age': 1, 'assignable': True},
1161                 {'username': 'blop', 'age': 1.5, 'assignable': True},
1162                 {'username': 'blorp', 'age': 2, 'assignable': False}):
1163             self.db.user.create(**user)
1164         file_content = ''.join([chr(i) for i in range(255)])
1165         f = self.db.file.create(content=file_content)
1166         for issue in (
1167                 {'title': 'issue one', 'status': '2', 'assignedto': '1',
1168                     'foo': date.Interval('1:10'), 'priority': '3',
1169                     'deadline': date.Date('2003-02-16.22:50')},
1170                 {'title': 'issue two', 'status': '1', 'assignedto': '2',
1171                     'foo': date.Interval('1d'), 'priority': '3',
1172                     'deadline': date.Date('2003-01-01.00:00')},
1173                 {'title': 'issue three', 'status': '1', 'priority': '2',
1174                     'nosy': ['1','2'], 'deadline': date.Date('2003-02-18')},
1175                 {'title': 'non four', 'status': '3',
1176                     'foo': date.Interval('0:10'), 'priority': '2',
1177                     'nosy': ['1','2','3'], 'deadline': date.Date('2004-03-08'),
1178                     'files': [f]}):
1179             self.db.issue.create(**issue)
1180         self.db.commit()
1181         return self.iterSetup(classname)
1182
1183     def testFilteringID(self):
1184         ae, filter, filter_iter = self.filteringSetup()
1185         for filt in filter, filter_iter:
1186             ae(filt(None, {'id': '1'}, ('+','id'), (None,None)), ['1'])
1187             ae(filt(None, {'id': '2'}, ('+','id'), (None,None)), ['2'])
1188             ae(filt(None, {'id': '100'}, ('+','id'), (None,None)), [])
1189
1190     def testFilteringBoolean(self):
1191         ae, filter, filter_iter = self.filteringSetup('user')
1192         a = 'assignable'
1193         for filt in filter, filter_iter:
1194             ae(filt(None, {a: '1'}, ('+','id'), (None,None)), ['3','4'])
1195             ae(filt(None, {a: '0'}, ('+','id'), (None,None)), ['5'])
1196             ae(filt(None, {a: ['1']}, ('+','id'), (None,None)), ['3','4'])
1197             ae(filt(None, {a: ['0']}, ('+','id'), (None,None)), ['5'])
1198             ae(filt(None, {a: ['0','1']}, ('+','id'), (None,None)),
1199                 ['3','4','5'])
1200             ae(filt(None, {a: 'True'}, ('+','id'), (None,None)), ['3','4'])
1201             ae(filt(None, {a: 'False'}, ('+','id'), (None,None)), ['5'])
1202             ae(filt(None, {a: ['True']}, ('+','id'), (None,None)), ['3','4'])
1203             ae(filt(None, {a: ['False']}, ('+','id'), (None,None)), ['5'])
1204             ae(filt(None, {a: ['False','True']}, ('+','id'), (None,None)),
1205                 ['3','4','5'])
1206             ae(filt(None, {a: True}, ('+','id'), (None,None)), ['3','4'])
1207             ae(filt(None, {a: False}, ('+','id'), (None,None)), ['5'])
1208             ae(filt(None, {a: 1}, ('+','id'), (None,None)), ['3','4'])
1209             ae(filt(None, {a: 0}, ('+','id'), (None,None)), ['5'])
1210             ae(filt(None, {a: [1]}, ('+','id'), (None,None)), ['3','4'])
1211             ae(filt(None, {a: [0]}, ('+','id'), (None,None)), ['5'])
1212             ae(filt(None, {a: [0,1]}, ('+','id'), (None,None)), ['3','4','5'])
1213             ae(filt(None, {a: [True]}, ('+','id'), (None,None)), ['3','4'])
1214             ae(filt(None, {a: [False]}, ('+','id'), (None,None)), ['5'])
1215             ae(filt(None, {a: [False,True]}, ('+','id'), (None,None)),
1216                 ['3','4','5'])
1217
1218     def testFilteringNumber(self):
1219         ae, filter, filter_iter = self.filteringSetup('user')
1220         for filt in filter, filter_iter:
1221             ae(filt(None, {'age': '1'}, ('+','id'), (None,None)), ['3'])
1222             ae(filt(None, {'age': '1.5'}, ('+','id'), (None,None)), ['4'])
1223             ae(filt(None, {'age': '2'}, ('+','id'), (None,None)), ['5'])
1224             ae(filt(None, {'age': ['1','2']}, ('+','id'), (None,None)),
1225                 ['3','5'])
1226             ae(filt(None, {'age': 2}, ('+','id'), (None,None)), ['5'])
1227             ae(filt(None, {'age': [1,2]}, ('+','id'), (None,None)), ['3','5'])
1228
1229     def testFilteringString(self):
1230         ae, filter, filter_iter = self.filteringSetup()
1231         for filt in filter, filter_iter:
1232             ae(filt(None, {'title': ['one']}, ('+','id'), (None,None)), ['1'])
1233             ae(filt(None, {'title': ['issue one']}, ('+','id'), (None,None)),
1234                 ['1'])
1235             ae(filt(None, {'title': ['issue', 'one']}, ('+','id'), (None,None)),
1236                 ['1'])
1237             ae(filt(None, {'title': ['issue']}, ('+','id'), (None,None)),
1238                 ['1','2','3'])
1239             ae(filt(None, {'title': ['one', 'two']}, ('+','id'), (None,None)),
1240                 [])
1241
1242     def testFilteringLink(self):
1243         ae, filter, filter_iter = self.filteringSetup()
1244         a = 'assignedto'
1245         grp = (None, None)
1246         for filt in filter, filter_iter:
1247             ae(filt(None, {'status': '1'}, ('+','id'), grp), ['2','3'])
1248             ae(filt(None, {a: '-1'}, ('+','id'), grp), ['3','4'])
1249             ae(filt(None, {a: None}, ('+','id'), grp), ['3','4'])
1250             ae(filt(None, {a: [None]}, ('+','id'), grp), ['3','4'])
1251             ae(filt(None, {a: ['-1', None]}, ('+','id'), grp), ['3','4'])
1252             ae(filt(None, {a: ['1', None]}, ('+','id'), grp), ['1', '3','4'])
1253
1254     def testFilteringMultilinkAndGroup(self):
1255         """testFilteringMultilinkAndGroup:
1256         See roundup Bug 1541128: apparently grouping by something and
1257         searching a Multilink failed with MySQL 5.0
1258         """
1259         ae, filter, filter_iter = self.filteringSetup()
1260         for f in filter, filter_iter:
1261             ae(f(None, {'files': '1'}, ('-','activity'), ('+','status')), ['4'])
1262
1263     def testFilteringRetired(self):
1264         ae, filter, filter_iter = self.filteringSetup()
1265         self.db.issue.retire('2')
1266         for f in filter, filter_iter:
1267             ae(f(None, {'status': '1'}, ('+','id'), (None,None)), ['3'])
1268
1269     def testFilteringMultilink(self):
1270         ae, filter, filter_iter = self.filteringSetup()
1271         for filt in filter, filter_iter:
1272             ae(filt(None, {'nosy': '3'}, ('+','id'), (None,None)), ['4'])
1273             ae(filt(None, {'nosy': '-1'}, ('+','id'), (None,None)), ['1', '2'])
1274             ae(filt(None, {'nosy': ['1','2']}, ('+', 'status'),
1275                 ('-', 'deadline')), ['4', '3'])
1276
1277     def testFilteringMany(self):
1278         ae, filter, filter_iter = self.filteringSetup()
1279         for f in filter, filter_iter:
1280             ae(f(None, {'nosy': '2', 'status': '1'}, ('+','id'), (None,None)),
1281                 ['3'])
1282
1283     def testFilteringRangeBasic(self):
1284         ae, filter, filter_iter = self.filteringSetup()
1285         d = 'deadline'
1286         for f in filter, filter_iter:
1287             ae(f(None, {d: 'from 2003-02-10 to 2003-02-23'}), ['1','3'])
1288             ae(f(None, {d: '2003-02-10; 2003-02-23'}), ['1','3'])
1289             ae(f(None, {d: '; 2003-02-16'}), ['2'])
1290
1291     def testFilteringRangeTwoSyntaxes(self):
1292         ae, filter, filter_iter = self.filteringSetup()
1293         for filt in filter, filter_iter:
1294             ae(filt(None, {'deadline': 'from 2003-02-16'}), ['1', '3', '4'])
1295             ae(filt(None, {'deadline': '2003-02-16;'}), ['1', '3', '4'])
1296
1297     def testFilteringRangeYearMonthDay(self):
1298         ae, filter, filter_iter = self.filteringSetup()
1299         for filt in filter, filter_iter:
1300             ae(filt(None, {'deadline': '2002'}), [])
1301             ae(filt(None, {'deadline': '2003'}), ['1', '2', '3'])
1302             ae(filt(None, {'deadline': '2004'}), ['4'])
1303             ae(filt(None, {'deadline': '2003-02-16'}), ['1'])
1304             ae(filt(None, {'deadline': '2003-02-17'}), [])
1305
1306     def testFilteringRangeMonths(self):
1307         ae, filter, filter_iter = self.filteringSetup()
1308         for month in range(1, 13):
1309             for n in range(1, month+1):
1310                 i = self.db.issue.create(title='%d.%d'%(month, n),
1311                     deadline=date.Date('2001-%02d-%02d.00:00'%(month, n)))
1312         self.db.commit()
1313
1314         for month in range(1, 13):
1315             for filt in filter, filter_iter:
1316                 r = filt(None, dict(deadline='2001-%02d'%month))
1317                 assert len(r) == month, 'month %d != length %d'%(month, len(r))
1318
1319     def testFilteringRangeInterval(self):
1320         ae, filter, filter_iter = self.filteringSetup()
1321         for filt in filter, filter_iter:
1322             ae(filt(None, {'foo': 'from 0:50 to 2:00'}), ['1'])
1323             ae(filt(None, {'foo': 'from 0:50 to 1d 2:00'}), ['1', '2'])
1324             ae(filt(None, {'foo': 'from 5:50'}), ['2'])
1325             ae(filt(None, {'foo': 'to 0:05'}), [])
1326
1327     def testFilteringRangeGeekInterval(self):
1328         ae, filter, filter_iter = self.filteringSetup()
1329         for issue in (
1330                 { 'deadline': date.Date('. -2d')},
1331                 { 'deadline': date.Date('. -1d')},
1332                 { 'deadline': date.Date('. -8d')},
1333                 ):
1334             self.db.issue.create(**issue)
1335         for filt in filter, filter_iter:
1336             ae(filt(None, {'deadline': '-2d;'}), ['5', '6'])
1337             ae(filt(None, {'deadline': '-1d;'}), ['6'])
1338             ae(filt(None, {'deadline': '-1w;'}), ['5', '6'])
1339
1340     def testFilteringIntervalSort(self):
1341         # 1: '1:10'
1342         # 2: '1d'
1343         # 3: None
1344         # 4: '0:10'
1345         ae, filter, filter_iter = self.filteringSetup()
1346         for filt in filter, filter_iter:
1347             # ascending should sort None, 1:10, 1d
1348             ae(filt(None, {}, ('+','foo'), (None,None)), ['3', '4', '1', '2'])
1349             # descending should sort 1d, 1:10, None
1350             ae(filt(None, {}, ('-','foo'), (None,None)), ['2', '1', '4', '3'])
1351
1352     def testFilteringStringSort(self):
1353         # 1: 'issue one'
1354         # 2: 'issue two'
1355         # 3: 'issue three'
1356         # 4: 'non four'
1357         ae, filter, filter_iter = self.filteringSetup()
1358         for filt in filter, filter_iter:
1359             ae(filt(None, {}, ('+','title')), ['1', '3', '2', '4'])
1360             ae(filt(None, {}, ('-','title')), ['4', '2', '3', '1'])
1361         # Test string case: For now allow both, w/wo case matching.
1362         # 1: 'issue one'
1363         # 2: 'issue two'
1364         # 3: 'Issue three'
1365         # 4: 'non four'
1366         self.db.issue.set('3', title='Issue three')
1367         for filt in filter, filter_iter:
1368             ae(filt(None, {}, ('+','title')), ['1', '3', '2', '4'])
1369             ae(filt(None, {}, ('-','title')), ['4', '2', '3', '1'])
1370         # Obscure bug in anydbm backend trying to convert to number
1371         # 1: '1st issue'
1372         # 2: '2'
1373         # 3: 'Issue three'
1374         # 4: 'non four'
1375         self.db.issue.set('1', title='1st issue')
1376         self.db.issue.set('2', title='2')
1377         for filt in filter, filter_iter:
1378             ae(filt(None, {}, ('+','title')), ['1', '2', '3', '4'])
1379             ae(filt(None, {}, ('-','title')), ['4', '3', '2', '1'])
1380
1381     def testFilteringMultilinkSort(self):
1382         # 1: []                 Reverse:  1: []
1383         # 2: []                           2: []
1384         # 3: ['admin','fred']             3: ['fred','admin']
1385         # 4: ['admin','bleep','fred']     4: ['fred','bleep','admin']
1386         # Note the sort order for the multilink doen't change when
1387         # reversing the sort direction due to the re-sorting of the
1388         # multilink!
1389         # Note that we don't test filter_iter here, Multilink sort-order
1390         # isn't defined for that.
1391         ae, filt, dummy = self.filteringSetup()
1392         ae(filt(None, {}, ('+','nosy'), (None,None)), ['1', '2', '4', '3'])
1393         ae(filt(None, {}, ('-','nosy'), (None,None)), ['4', '3', '1', '2'])
1394
1395     def testFilteringMultilinkSortGroup(self):
1396         # 1: status: 2 "in-progress" nosy: []
1397         # 2: status: 1 "unread"      nosy: []
1398         # 3: status: 1 "unread"      nosy: ['admin','fred']
1399         # 4: status: 3 "testing"     nosy: ['admin','bleep','fred']
1400         # Note that we don't test filter_iter here, Multilink sort-order
1401         # isn't defined for that.
1402         ae, filt, dummy = self.filteringSetup()
1403         ae(filt(None, {}, ('+','nosy'), ('+','status')), ['1', '4', '2', '3'])
1404         ae(filt(None, {}, ('-','nosy'), ('+','status')), ['1', '4', '3', '2'])
1405         ae(filt(None, {}, ('+','nosy'), ('-','status')), ['2', '3', '4', '1'])
1406         ae(filt(None, {}, ('-','nosy'), ('-','status')), ['3', '2', '4', '1'])
1407         ae(filt(None, {}, ('+','status'), ('+','nosy')), ['1', '2', '4', '3'])
1408         ae(filt(None, {}, ('-','status'), ('+','nosy')), ['2', '1', '4', '3'])
1409         ae(filt(None, {}, ('+','status'), ('-','nosy')), ['4', '3', '1', '2'])
1410         ae(filt(None, {}, ('-','status'), ('-','nosy')), ['4', '3', '2', '1'])
1411
1412     def testFilteringLinkSortGroup(self):
1413         # 1: status: 2 -> 'i', priority: 3 -> 1
1414         # 2: status: 1 -> 'u', priority: 3 -> 1
1415         # 3: status: 1 -> 'u', priority: 2 -> 3
1416         # 4: status: 3 -> 't', priority: 2 -> 3
1417         ae, filter, filter_iter = self.filteringSetup()
1418         for filt in filter, filter_iter:
1419             ae(filt(None, {}, ('+','status'), ('+','priority')),
1420                 ['1', '2', '4', '3'])
1421             ae(filt(None, {'priority':'2'}, ('+','status'), ('+','priority')),
1422                 ['4', '3'])
1423             ae(filt(None, {'priority.order':'3'}, ('+','status'),
1424                 ('+','priority')), ['4', '3'])
1425             ae(filt(None, {'priority':['2','3']}, ('+','priority'),
1426                 ('+','status')), ['1', '4', '2', '3'])
1427             ae(filt(None, {}, ('+','priority'), ('+','status')),
1428                 ['1', '4', '2', '3'])
1429
1430     def testFilteringDateSort(self):
1431         # '1': '2003-02-16.22:50'
1432         # '2': '2003-01-01.00:00'
1433         # '3': '2003-02-18'
1434         # '4': '2004-03-08'
1435         ae, filter, filter_iter = self.filteringSetup()
1436         for f in filter, filter_iter:
1437             # ascending
1438             ae(f(None, {}, ('+','deadline'), (None,None)), ['2', '1', '3', '4'])
1439             # descending
1440             ae(f(None, {}, ('-','deadline'), (None,None)), ['4', '3', '1', '2'])
1441
1442     def testFilteringDateSortPriorityGroup(self):
1443         # '1': '2003-02-16.22:50'  1 => 2
1444         # '2': '2003-01-01.00:00'  3 => 1
1445         # '3': '2003-02-18'        2 => 3
1446         # '4': '2004-03-08'        1 => 2
1447         ae, filter, filter_iter = self.filteringSetup()
1448
1449         for filt in filter, filter_iter:
1450             # ascending
1451             ae(filt(None, {}, ('+','deadline'), ('+','priority')),
1452                 ['2', '1', '3', '4'])
1453             ae(filt(None, {}, ('-','deadline'), ('+','priority')),
1454                 ['1', '2', '4', '3'])
1455             # descending
1456             ae(filt(None, {}, ('+','deadline'), ('-','priority')),
1457                 ['3', '4', '2', '1'])
1458             ae(filt(None, {}, ('-','deadline'), ('-','priority')),
1459                 ['4', '3', '1', '2'])
1460
1461     def testFilteringTransitiveLinkUser(self):
1462         ae, filter, filter_iter = self.filteringSetupTransitiveSearch('user')
1463         for f in filter, filter_iter:
1464             ae(f(None, {'supervisor.username': 'ceo'}, ('+','username')),
1465                 ['4', '5'])
1466             ae(f(None, {'supervisor.supervisor.username': 'ceo'},
1467                 ('+','username')), ['6', '7', '8', '9', '10'])
1468             ae(f(None, {'supervisor.supervisor': '3'}, ('+','username')),
1469                 ['6', '7', '8', '9', '10'])
1470             ae(f(None, {'supervisor.supervisor.id': '3'}, ('+','username')),
1471                 ['6', '7', '8', '9', '10'])
1472             ae(f(None, {'supervisor.username': 'grouplead1'}, ('+','username')),
1473                 ['6', '7'])
1474             ae(f(None, {'supervisor.username': 'grouplead2'}, ('+','username')),
1475                 ['8', '9', '10'])
1476             ae(f(None, {'supervisor.username': 'grouplead2',
1477                 'supervisor.supervisor.username': 'ceo'}, ('+','username')),
1478                 ['8', '9', '10'])
1479             ae(f(None, {'supervisor.supervisor': '3', 'supervisor': '4'},
1480                 ('+','username')), ['6', '7'])
1481
1482     def testFilteringTransitiveLinkSort(self):
1483         ae, filter, filter_iter = self.filteringSetupTransitiveSearch()
1484         ae, ufilter, ufilter_iter = self.iterSetup('user')
1485         # Need to make ceo his own (and first two users') supervisor,
1486         # otherwise we will depend on sorting order of NULL values.
1487         # Leave that to a separate test.
1488         self.db.user.set('1', supervisor = '3')
1489         self.db.user.set('2', supervisor = '3')
1490         self.db.user.set('3', supervisor = '3')
1491         for ufilt in ufilter, ufilter_iter:
1492             ae(ufilt(None, {'supervisor':'3'}, []), ['1', '2', '3', '4', '5'])
1493             ae(ufilt(None, {}, [('+','supervisor.supervisor.supervisor'),
1494                 ('+','supervisor.supervisor'), ('+','supervisor'),
1495                 ('+','username')]),
1496                 ['1', '3', '2', '4', '5', '6', '7', '8', '9', '10'])
1497             ae(ufilt(None, {}, [('+','supervisor.supervisor.supervisor'),
1498                 ('-','supervisor.supervisor'), ('-','supervisor'),
1499                 ('+','username')]),
1500                 ['8', '9', '10', '6', '7', '1', '3', '2', '4', '5'])
1501         for f in filter, filter_iter:
1502             ae(f(None, {}, [('+','assignedto.supervisor.supervisor.supervisor'),
1503                 ('+','assignedto.supervisor.supervisor'),
1504                 ('+','assignedto.supervisor'), ('+','assignedto')]),
1505                 ['1', '2', '3', '4', '5', '6', '7', '8'])
1506             ae(f(None, {}, [('+','assignedto.supervisor.supervisor.supervisor'),
1507                 ('+','assignedto.supervisor.supervisor'),
1508                 ('-','assignedto.supervisor'), ('+','assignedto')]),
1509                 ['4', '5', '6', '7', '8', '1', '2', '3'])
1510             ae(f(None, {}, [('+','assignedto.supervisor.supervisor.supervisor'),
1511                 ('+','assignedto.supervisor.supervisor'),
1512                 ('+','assignedto.supervisor'), ('+','assignedto'),
1513                 ('-','status')]),
1514                 ['2', '1', '3', '4', '5', '6', '8', '7'])
1515             ae(f(None, {}, [('+','assignedto.supervisor.supervisor.supervisor'),
1516                 ('+','assignedto.supervisor.supervisor'),
1517                 ('+','assignedto.supervisor'), ('+','assignedto'),
1518                 ('+','status')]),
1519                 ['1', '2', '3', '4', '5', '7', '6', '8'])
1520             ae(f(None, {}, [('+','assignedto.supervisor.supervisor.supervisor'),
1521                 ('+','assignedto.supervisor.supervisor'),
1522                 ('-','assignedto.supervisor'), ('+','assignedto'),
1523                 ('+','status')]), ['4', '5', '7', '6', '8', '1', '2', '3'])
1524             ae(f(None, {'assignedto':['6','7','8','9','10']},
1525                 [('+','assignedto.supervisor.supervisor.supervisor'),
1526                 ('+','assignedto.supervisor.supervisor'),
1527                 ('-','assignedto.supervisor'), ('+','assignedto'),
1528                 ('+','status')]), ['4', '5', '7', '6', '8', '1', '2', '3'])
1529             ae(f(None, {'assignedto':['6','7','8','9']},
1530                 [('+','assignedto.supervisor.supervisor.supervisor'),
1531                 ('+','assignedto.supervisor.supervisor'),
1532                 ('-','assignedto.supervisor'), ('+','assignedto'),
1533                 ('+','status')]), ['4', '5', '1', '2', '3'])
1534
1535     def testFilteringTransitiveLinkSortNull(self):
1536         """Check sorting of NULL values"""
1537         ae, filter, filter_iter = self.filteringSetupTransitiveSearch()
1538         ae, ufilter, ufilter_iter = self.iterSetup('user')
1539         for ufilt in ufilter, ufilter_iter:
1540             ae(ufilt(None, {}, [('+','supervisor.supervisor.supervisor'),
1541                 ('+','supervisor.supervisor'), ('+','supervisor'),
1542                 ('+','username')]),
1543                 ['1', '3', '2', '4', '5', '6', '7', '8', '9', '10'])
1544             ae(ufilt(None, {}, [('+','supervisor.supervisor.supervisor'),
1545                 ('-','supervisor.supervisor'), ('-','supervisor'),
1546                 ('+','username')]),
1547                 ['8', '9', '10', '6', '7', '4', '5', '1', '3', '2'])
1548         for f in filter, filter_iter:
1549             ae(f(None, {}, [('+','assignedto.supervisor.supervisor.supervisor'),
1550                 ('+','assignedto.supervisor.supervisor'),
1551                 ('+','assignedto.supervisor'), ('+','assignedto')]),
1552                 ['1', '2', '3', '4', '5', '6', '7', '8'])
1553             ae(f(None, {}, [('+','assignedto.supervisor.supervisor.supervisor'),
1554                 ('+','assignedto.supervisor.supervisor'),
1555                 ('-','assignedto.supervisor'), ('+','assignedto')]),
1556                 ['4', '5', '6', '7', '8', '1', '2', '3'])
1557
1558     def testFilteringTransitiveLinkIssue(self):
1559         ae, filter, filter_iter = self.filteringSetupTransitiveSearch()
1560         for filt in filter, filter_iter:
1561             ae(filt(None, {'assignedto.supervisor.username': 'grouplead1'},
1562                 ('+','id')), ['1', '2', '3'])
1563             ae(filt(None, {'assignedto.supervisor.username': 'grouplead2'},
1564                 ('+','id')), ['4', '5', '6', '7', '8'])
1565             ae(filt(None, {'assignedto.supervisor.username': 'grouplead2',
1566                            'status': '1'}, ('+','id')), ['4', '6', '8'])
1567             ae(filt(None, {'assignedto.supervisor.username': 'grouplead2',
1568                            'status': '2'}, ('+','id')), ['5', '7'])
1569             ae(filt(None, {'assignedto.supervisor.username': ['grouplead2'],
1570                            'status': '2'}, ('+','id')), ['5', '7'])
1571             ae(filt(None, {'assignedto.supervisor': ['4', '5'], 'status': '2'},
1572                 ('+','id')), ['1', '3', '5', '7'])
1573
1574     def testFilteringTransitiveMultilink(self):
1575         ae, filter, filter_iter = self.filteringSetupTransitiveSearch()
1576         for filt in filter, filter_iter:
1577             ae(filt(None, {'messages.author.username': 'grouplead1'},
1578                 ('+','id')), [])
1579             ae(filt(None, {'messages.author': '6'},
1580                 ('+','id')), ['1', '2'])
1581             ae(filt(None, {'messages.author.id': '6'},
1582                 ('+','id')), ['1', '2'])
1583             ae(filt(None, {'messages.author.username': 'worker1'},
1584                 ('+','id')), ['1', '2'])
1585             ae(filt(None, {'messages.author': '10'},
1586                 ('+','id')), ['6', '7', '8'])
1587             ae(filt(None, {'messages.author': '9'},
1588                 ('+','id')), ['5', '8'])
1589             ae(filt(None, {'messages.author': ['9', '10']},
1590                 ('+','id')), ['5', '6', '7', '8'])
1591             ae(filt(None, {'messages.author': ['8', '9']},
1592                 ('+','id')), ['4', '5', '8'])
1593             ae(filt(None, {'messages.author': ['8', '9'], 'status' : '1'},
1594                 ('+','id')), ['4', '8'])
1595             ae(filt(None, {'messages.author': ['8', '9'], 'status' : '2'},
1596                 ('+','id')), ['5'])
1597             ae(filt(None, {'messages.author': ['8', '9', '10'],
1598                 'messages.date': '2006-01-22.21:00;2006-01-23'}, ('+','id')),
1599                 ['6', '7', '8'])
1600             ae(filt(None, {'nosy.supervisor.username': 'ceo'},
1601                 ('+','id')), ['1', '2'])
1602             ae(filt(None, {'messages.author': ['6', '9']},
1603                 ('+','id')), ['1', '2', '5', '8'])
1604             ae(filt(None, {'messages': ['5', '7']},
1605                 ('+','id')), ['3', '5', '8'])
1606             ae(filt(None, {'messages.author': ['6', '9'],
1607                 'messages': ['5', '7']}, ('+','id')), ['5', '8'])
1608
1609     def testFilteringTransitiveMultilinkSort(self):
1610         # Note that we don't test filter_iter here, Multilink sort-order
1611         # isn't defined for that.
1612         ae, filt, dummy = self.filteringSetupTransitiveSearch()
1613         ae(filt(None, {}, [('+','messages.author')]),
1614             ['1', '2', '3', '4', '5', '8', '6', '7'])
1615         ae(filt(None, {}, [('-','messages.author')]),
1616             ['8', '6', '7', '5', '4', '3', '1', '2'])
1617         ae(filt(None, {}, [('+','messages.date')]),
1618             ['6', '7', '8', '5', '4', '3', '1', '2'])
1619         ae(filt(None, {}, [('-','messages.date')]),
1620             ['1', '2', '3', '4', '8', '5', '6', '7'])
1621         ae(filt(None, {}, [('+','messages.author'),('+','messages.date')]),
1622             ['1', '2', '3', '4', '5', '8', '6', '7'])
1623         ae(filt(None, {}, [('-','messages.author'),('+','messages.date')]),
1624             ['8', '6', '7', '5', '4', '3', '1', '2'])
1625         ae(filt(None, {}, [('+','messages.author'),('-','messages.date')]),
1626             ['1', '2', '3', '4', '5', '8', '6', '7'])
1627         ae(filt(None, {}, [('-','messages.author'),('-','messages.date')]),
1628             ['8', '6', '7', '5', '4', '3', '1', '2'])
1629         ae(filt(None, {}, [('+','messages.author'),('+','assignedto')]),
1630             ['1', '2', '3', '4', '5', '8', '6', '7'])
1631         ae(filt(None, {}, [('+','messages.author'),
1632             ('-','assignedto.supervisor'),('-','assignedto')]),
1633             ['1', '2', '3', '4', '5', '8', '6', '7'])
1634         ae(filt(None, {},
1635             [('+','messages.author.supervisor.supervisor.supervisor'),
1636             ('+','messages.author.supervisor.supervisor'),
1637             ('+','messages.author.supervisor'), ('+','messages.author')]),
1638             ['1', '2', '3', '4', '5', '6', '7', '8'])
1639         self.db.user.setorderprop('age')
1640         self.db.msg.setorderprop('date')
1641         ae(filt(None, {}, [('+','messages'), ('+','messages.author')]),
1642             ['6', '7', '8', '5', '4', '3', '1', '2'])
1643         ae(filt(None, {}, [('+','messages.author'), ('+','messages')]),
1644             ['6', '7', '8', '5', '4', '3', '1', '2'])
1645         self.db.msg.setorderprop('author')
1646         # Orderprop is a Link/Multilink:
1647         # messages are sorted by orderprop().labelprop(), i.e. by
1648         # author.username, *not* by author.orderprop() (author.age)!
1649         ae(filt(None, {}, [('+','messages')]),
1650             ['1', '2', '3', '4', '5', '8', '6', '7'])
1651         ae(filt(None, {}, [('+','messages.author'), ('+','messages')]),
1652             ['6', '7', '8', '5', '4', '3', '1', '2'])
1653         # The following will sort by
1654         # author.supervisor.username and then by
1655         # author.username
1656         # I've resited the tempation to implement recursive orderprop
1657         # here: There could even be loops if several classes specify a
1658         # Link or Multilink as the orderprop...
1659         # msg: 4: worker1 (id  5) : grouplead1 (id 4) ceo (id 3)
1660         # msg: 5: worker2 (id  7) : grouplead1 (id 4) ceo (id 3)
1661         # msg: 6: worker3 (id  8) : grouplead2 (id 5) ceo (id 3)
1662         # msg: 7: worker4 (id  9) : grouplead2 (id 5) ceo (id 3)
1663         # msg: 8: worker5 (id 10) : grouplead2 (id 5) ceo (id 3)
1664         # issue 1: messages 4   sortkey:[[grouplead1], [worker1], 1]
1665         # issue 2: messages 4   sortkey:[[grouplead1], [worker1], 2]
1666         # issue 3: messages 5   sortkey:[[grouplead1], [worker2], 3]
1667         # issue 4: messages 6   sortkey:[[grouplead2], [worker3], 4]
1668         # issue 5: messages 7   sortkey:[[grouplead2], [worker4], 5]
1669         # issue 6: messages 8   sortkey:[[grouplead2], [worker5], 6]
1670         # issue 7: messages 8   sortkey:[[grouplead2], [worker5], 7]
1671         # issue 8: messages 7,8 sortkey:[[grouplead2, grouplead2], ...]
1672         self.db.user.setorderprop('supervisor')
1673         ae(filt(None, {}, [('+','messages.author'), ('-','messages')]),
1674             ['3', '1', '2', '6', '7', '5', '4', '8'])
1675
1676     def testFilteringSortId(self):
1677         ae, filter, filter_iter = self.filteringSetupTransitiveSearch('user')
1678         for filt in filter, filter_iter:
1679             ae(filt(None, {}, ('+','id')),
1680                 ['1', '2', '3', '4', '5', '6', '7', '8', '9', '10'])
1681
1682 # XXX add sorting tests for other types
1683
1684     # nuke and re-create db for restore
1685     def nukeAndCreate(self):
1686         # shut down this db and nuke it
1687         self.db.close()
1688         self.nuke_database()
1689
1690         # open a new, empty database
1691         os.makedirs(config.DATABASE + '/files')
1692         self.db = self.module.Database(config, 'admin')
1693         setupSchema(self.db, 0, self.module)
1694
1695     def testImportExport(self):
1696         # use the filtering setup to create a bunch of items
1697         ae, dummy1, dummy2 = self.filteringSetup()
1698         # Get some stuff into the journal for testing import/export of
1699         # journal data:
1700         self.db.user.set('4', password = password.Password('xyzzy'))
1701         self.db.user.set('4', age = 3)
1702         self.db.user.set('4', assignable = True)
1703         self.db.issue.set('1', title = 'i1', status = '3')
1704         self.db.issue.set('1', deadline = date.Date('2007'))
1705         self.db.issue.set('1', foo = date.Interval('1:20'))
1706         p = self.db.priority.create(name = 'some_prio_without_order')
1707         self.db.commit()
1708         self.db.user.set('4', password = password.Password('123xyzzy'))
1709         self.db.user.set('4', assignable = False)
1710         self.db.priority.set(p, order = '4711')
1711         self.db.commit()
1712
1713         self.db.user.retire('3')
1714         self.db.issue.retire('2')
1715
1716         # grab snapshot of the current database
1717         orig = {}
1718         origj = {}
1719         for cn,klass in self.db.classes.items():
1720             cl = orig[cn] = {}
1721             jn = origj[cn] = {}
1722             for id in klass.list():
1723                 it = cl[id] = {}
1724                 jn[id] = self.db.getjournal(cn, id)
1725                 for name in klass.getprops().keys():
1726                     it[name] = klass.get(id, name)
1727
1728         os.mkdir('_test_export')
1729         try:
1730             # grab the export
1731             export = {}
1732             journals = {}
1733             for cn,klass in self.db.classes.items():
1734                 names = klass.export_propnames()
1735                 cl = export[cn] = [names+['is retired']]
1736                 for id in klass.getnodeids():
1737                     cl.append(klass.export_list(names, id))
1738                     if hasattr(klass, 'export_files'):
1739                         klass.export_files('_test_export', id)
1740                 journals[cn] = klass.export_journals()
1741
1742             self.nukeAndCreate()
1743
1744             # import
1745             for cn, items in export.items():
1746                 klass = self.db.classes[cn]
1747                 names = items[0]
1748                 maxid = 1
1749                 for itemprops in items[1:]:
1750                     id = int(klass.import_list(names, itemprops))
1751                     if hasattr(klass, 'import_files'):
1752                         klass.import_files('_test_export', str(id))
1753                     maxid = max(maxid, id)
1754                 self.db.setid(cn, str(maxid+1))
1755                 klass.import_journals(journals[cn])
1756             # This is needed, otherwise journals won't be there for anydbm
1757             self.db.commit()
1758         finally:
1759             shutil.rmtree('_test_export')
1760
1761         # compare with snapshot of the database
1762         for cn, items in orig.iteritems():
1763             klass = self.db.classes[cn]
1764             propdefs = klass.getprops(1)
1765             # ensure retired items are retired :)
1766             l = items.keys(); l.sort()
1767             m = klass.list(); m.sort()
1768             ae(l, m, '%s id list wrong %r vs. %r'%(cn, l, m))
1769             for id, props in items.items():
1770                 for name, value in props.items():
1771                     l = klass.get(id, name)
1772                     if isinstance(value, type([])):
1773                         value.sort()
1774                         l.sort()
1775                     try:
1776                         ae(l, value)
1777                     except AssertionError:
1778                         if not isinstance(propdefs[name], Date):
1779                             raise
1780                         # don't get hung up on rounding errors
1781                         assert not l.__cmp__(value, int_seconds=1)
1782         for jc, items in origj.iteritems():
1783             for id, oj in items.iteritems():
1784                 rj = self.db.getjournal(jc, id)
1785                 # Both mysql and postgresql have some minor issues with
1786                 # rounded seconds on export/import, so we compare only
1787                 # the integer part.
1788                 for j in oj:
1789                     j[1].second = float(int(j[1].second))
1790                 for j in rj:
1791                     j[1].second = float(int(j[1].second))
1792                 oj.sort()
1793                 rj.sort()
1794                 ae(oj, rj)
1795
1796         # make sure the retired items are actually imported
1797         ae(self.db.user.get('4', 'username'), 'blop')
1798         ae(self.db.issue.get('2', 'title'), 'issue two')
1799
1800         # make sure id counters are set correctly
1801         maxid = max([int(id) for id in self.db.user.list()])
1802         newid = self.db.user.create(username='testing')
1803         assert newid > maxid
1804
1805     # test import/export via admin interface
1806     def testAdminImportExport(self):
1807         import roundup.admin
1808         import csv
1809         # use the filtering setup to create a bunch of items
1810         ae, dummy1, dummy2 = self.filteringSetup()
1811         # create large field
1812         self.db.priority.create(name = 'X' * 500)
1813         self.db.config.CSV_FIELD_SIZE = 400
1814         self.db.commit()
1815         output = []
1816         # ugly hack to get stderr output and disable stdout output
1817         # during regression test. Depends on roundup.admin not using
1818         # anything but stdout/stderr from sys (which is currently the
1819         # case)
1820         def stderrwrite(s):
1821             output.append(s)
1822         roundup.admin.sys = MockNull ()
1823         try:
1824             roundup.admin.sys.stderr.write = stderrwrite
1825             tool = roundup.admin.AdminTool()
1826             home = '.'
1827             tool.tracker_home = home
1828             tool.db = self.db
1829             tool.verbose = False
1830             tool.do_export (['_test_export'])
1831             self.assertEqual(len(output), 2)
1832             self.assertEqual(output [1], '\n')
1833             self.failUnless(output [0].startswith
1834                 ('Warning: config csv_field_size should be at least'))
1835             self.failUnless(int(output[0].split()[-1]) > 500)
1836
1837             if hasattr(roundup.admin.csv, 'field_size_limit'):
1838                 self.nukeAndCreate()
1839                 self.db.config.CSV_FIELD_SIZE = 400
1840                 tool = roundup.admin.AdminTool()
1841                 tool.tracker_home = home
1842                 tool.db = self.db
1843                 tool.verbose = False
1844                 self.assertRaises(csv.Error, tool.do_import, ['_test_export'])
1845
1846             self.nukeAndCreate()
1847             self.db.config.CSV_FIELD_SIZE = 3200
1848             tool = roundup.admin.AdminTool()
1849             tool.tracker_home = home
1850             tool.db = self.db
1851             tool.verbose = False
1852             tool.do_import(['_test_export'])
1853         finally:
1854             roundup.admin.sys = sys
1855             shutil.rmtree('_test_export')
1856
1857     def testAddProperty(self):
1858         self.db.issue.create(title="spam", status='1')
1859         self.db.commit()
1860
1861         self.db.issue.addprop(fixer=Link("user"))
1862         # force any post-init stuff to happen
1863         self.db.post_init()
1864         props = self.db.issue.getprops()
1865         keys = props.keys()
1866         keys.sort()
1867         self.assertEqual(keys, ['activity', 'actor', 'assignedto', 'creation',
1868             'creator', 'deadline', 'feedback', 'files', 'fixer', 'foo', 'id', 'messages',
1869             'nosy', 'priority', 'spam', 'status', 'superseder', 'title'])
1870         self.assertEqual(self.db.issue.get('1', "fixer"), None)
1871
1872     def testRemoveProperty(self):
1873         self.db.issue.create(title="spam", status='1')
1874         self.db.commit()
1875
1876         del self.db.issue.properties['title']
1877         self.db.post_init()
1878         props = self.db.issue.getprops()
1879         keys = props.keys()
1880         keys.sort()
1881         self.assertEqual(keys, ['activity', 'actor', 'assignedto', 'creation',
1882             'creator', 'deadline', 'feedback', 'files', 'foo', 'id', 'messages',
1883             'nosy', 'priority', 'spam', 'status', 'superseder'])
1884         self.assertEqual(self.db.issue.list(), ['1'])
1885
1886     def testAddRemoveProperty(self):
1887         self.db.issue.create(title="spam", status='1')
1888         self.db.commit()
1889
1890         self.db.issue.addprop(fixer=Link("user"))
1891         del self.db.issue.properties['title']
1892         self.db.post_init()
1893         props = self.db.issue.getprops()
1894         keys = props.keys()
1895         keys.sort()
1896         self.assertEqual(keys, ['activity', 'actor', 'assignedto', 'creation',
1897             'creator', 'deadline', 'feedback', 'files', 'fixer', 'foo', 'id',
1898             'messages', 'nosy', 'priority', 'spam', 'status', 'superseder'])
1899         self.assertEqual(self.db.issue.list(), ['1'])
1900
1901     def testNosyMail(self) :
1902         """Creates one issue with two attachments, one smaller and one larger
1903            than the set max_attachment_size.
1904         """
1905         old_translate_ = roundupdb._
1906         roundupdb._ = i18n.get_translation(language='C').gettext
1907         db = self.db
1908         db.config.NOSY_MAX_ATTACHMENT_SIZE = 4096
1909         res = dict(mail_to = None, mail_msg = None)
1910         def dummy_snd(s, to, msg, res=res) :
1911             res["mail_to"], res["mail_msg"] = to, msg
1912         backup, Mailer.smtp_send = Mailer.smtp_send, dummy_snd
1913         try :
1914             f1 = db.file.create(name="test1.txt", content="x" * 20)
1915             f2 = db.file.create(name="test2.txt", content="y" * 5000)
1916             m  = db.msg.create(content="one two", author="admin",
1917                 files = [f1, f2])
1918             i  = db.issue.create(title='spam', files = [f1, f2],
1919                 messages = [m], nosy = [db.user.lookup("fred")])
1920
1921             db.issue.nosymessage(i, m, {})
1922             mail_msg = str(res["mail_msg"])
1923             self.assertEqual(res["mail_to"], ["fred@example.com"])
1924             self.assert_("From: admin" in mail_msg)
1925             self.assert_("Subject: [issue1] spam" in mail_msg)
1926             self.assert_("New submission from admin" in mail_msg)
1927             self.assert_("one two" in mail_msg)
1928             self.assert_("File 'test1.txt' not attached" not in mail_msg)
1929             self.assert_(base64.encodestring("xxx").rstrip() in mail_msg)
1930             self.assert_("File 'test2.txt' not attached" in mail_msg)
1931             self.assert_(base64.encodestring("yyy").rstrip() not in mail_msg)
1932         finally :
1933             roundupdb._ = old_translate_
1934             Mailer.smtp_send = backup
1935
1936 class ROTest(MyTestCase):
1937     def setUp(self):
1938         # remove previous test, ignore errors
1939         if os.path.exists(config.DATABASE):
1940             shutil.rmtree(config.DATABASE)
1941         os.makedirs(config.DATABASE + '/files')
1942         self.db = self.module.Database(config, 'admin')
1943         setupSchema(self.db, 1, self.module)
1944         self.db.close()
1945
1946         self.db = self.module.Database(config)
1947         setupSchema(self.db, 0, self.module)
1948
1949     def testExceptions(self):
1950         # this tests the exceptions that should be raised
1951         ar = self.assertRaises
1952
1953         # this tests the exceptions that should be raised
1954         ar(DatabaseError, self.db.status.create, name="foo")
1955         ar(DatabaseError, self.db.status.set, '1', name="foo")
1956         ar(DatabaseError, self.db.status.retire, '1')
1957
1958
1959 class SchemaTest(MyTestCase):
1960     def setUp(self):
1961         # remove previous test, ignore errors
1962         if os.path.exists(config.DATABASE):
1963             shutil.rmtree(config.DATABASE)
1964         os.makedirs(config.DATABASE + '/files')
1965
1966     def test_reservedProperties(self):
1967         self.open_database()
1968         self.assertRaises(ValueError, self.module.Class, self.db, "a",
1969             creation=String())
1970         self.assertRaises(ValueError, self.module.Class, self.db, "a",
1971             activity=String())
1972         self.assertRaises(ValueError, self.module.Class, self.db, "a",
1973             creator=String())
1974         self.assertRaises(ValueError, self.module.Class, self.db, "a",
1975             actor=String())
1976
1977     def init_a(self):
1978         self.open_database()
1979         a = self.module.Class(self.db, "a", name=String())
1980         a.setkey("name")
1981         self.db.post_init()
1982
1983     def test_fileClassProps(self):
1984         self.open_database()
1985         a = self.module.FileClass(self.db, 'a')
1986         l = a.getprops().keys()
1987         l.sort()
1988         self.assert_(l, ['activity', 'actor', 'content', 'created',
1989             'creation', 'type'])
1990
1991     def init_ab(self):
1992         self.open_database()
1993         a = self.module.Class(self.db, "a", name=String())
1994         a.setkey("name")
1995         b = self.module.Class(self.db, "b", name=String(),
1996             fooz=Multilink('a'))
1997         b.setkey("name")
1998         self.db.post_init()
1999
2000     def test_addNewClass(self):
2001         self.init_a()
2002
2003         self.assertRaises(ValueError, self.module.Class, self.db, "a",
2004             name=String())
2005
2006         aid = self.db.a.create(name='apple')
2007         self.db.commit(); self.db.close()
2008
2009         # add a new class to the schema and check creation of new items
2010         # (and existence of old ones)
2011         self.init_ab()
2012         bid = self.db.b.create(name='bear', fooz=[aid])
2013         self.assertEqual(self.db.a.get(aid, 'name'), 'apple')
2014         self.db.commit()
2015         self.db.close()
2016
2017         # now check we can recall the added class' items
2018         self.init_ab()
2019         self.assertEqual(self.db.a.get(aid, 'name'), 'apple')
2020         self.assertEqual(self.db.a.lookup('apple'), aid)
2021         self.assertEqual(self.db.b.get(bid, 'name'), 'bear')
2022         self.assertEqual(self.db.b.get(bid, 'fooz'), [aid])
2023         self.assertEqual(self.db.b.lookup('bear'), bid)
2024
2025         # confirm journal's ok
2026         self.db.getjournal('a', aid)
2027         self.db.getjournal('b', bid)
2028
2029     def init_amod(self):
2030         self.open_database()
2031         a = self.module.Class(self.db, "a", name=String(), newstr=String(),
2032             newint=Interval(), newnum=Number(), newbool=Boolean(),
2033             newdate=Date())
2034         a.setkey("name")
2035         b = self.module.Class(self.db, "b", name=String())
2036         b.setkey("name")
2037         self.db.post_init()
2038
2039     def test_modifyClass(self):
2040         self.init_ab()
2041
2042         # add item to user and issue class
2043         aid = self.db.a.create(name='apple')
2044         bid = self.db.b.create(name='bear')
2045         self.db.commit(); self.db.close()
2046
2047         # modify "a" schema
2048         self.init_amod()
2049         self.assertEqual(self.db.a.get(aid, 'name'), 'apple')
2050         self.assertEqual(self.db.a.get(aid, 'newstr'), None)
2051         self.assertEqual(self.db.a.get(aid, 'newint'), None)
2052         # hack - metakit can't return None for missing values, and we're not
2053         # really checking for that behavior here anyway
2054         self.assert_(not self.db.a.get(aid, 'newnum'))
2055         self.assert_(not self.db.a.get(aid, 'newbool'))
2056         self.assertEqual(self.db.a.get(aid, 'newdate'), None)
2057         self.assertEqual(self.db.b.get(aid, 'name'), 'bear')
2058         aid2 = self.db.a.create(name='aardvark', newstr='booz')
2059         self.db.commit(); self.db.close()
2060
2061         # test
2062         self.init_amod()
2063         self.assertEqual(self.db.a.get(aid, 'name'), 'apple')
2064         self.assertEqual(self.db.a.get(aid, 'newstr'), None)
2065         self.assertEqual(self.db.b.get(aid, 'name'), 'bear')
2066         self.assertEqual(self.db.a.get(aid2, 'name'), 'aardvark')
2067         self.assertEqual(self.db.a.get(aid2, 'newstr'), 'booz')
2068
2069         # confirm journal's ok
2070         self.db.getjournal('a', aid)
2071         self.db.getjournal('a', aid2)
2072
2073     def init_amodkey(self):
2074         self.open_database()
2075         a = self.module.Class(self.db, "a", name=String(), newstr=String())
2076         a.setkey("newstr")
2077         b = self.module.Class(self.db, "b", name=String())
2078         b.setkey("name")
2079         self.db.post_init()
2080
2081     def test_changeClassKey(self):
2082         self.init_amod()
2083         aid = self.db.a.create(name='apple')
2084         self.assertEqual(self.db.a.lookup('apple'), aid)
2085         self.db.commit(); self.db.close()
2086
2087         # change the key to newstr on a
2088         self.init_amodkey()
2089         self.assertEqual(self.db.a.get(aid, 'name'), 'apple')
2090         self.assertEqual(self.db.a.get(aid, 'newstr'), None)
2091         self.assertRaises(KeyError, self.db.a.lookup, 'apple')
2092         aid2 = self.db.a.create(name='aardvark', newstr='booz')
2093         self.db.commit(); self.db.close()
2094
2095         # check
2096         self.init_amodkey()
2097         self.assertEqual(self.db.a.lookup('booz'), aid2)
2098
2099         # confirm journal's ok
2100         self.db.getjournal('a', aid)
2101
2102     def test_removeClassKey(self):
2103         self.init_amod()
2104         aid = self.db.a.create(name='apple')
2105         self.assertEqual(self.db.a.lookup('apple'), aid)
2106         self.db.commit(); self.db.close()
2107
2108         self.db = self.module.Database(config, 'admin')
2109         a = self.module.Class(self.db, "a", name=String(), newstr=String())
2110         self.db.post_init()
2111
2112         aid2 = self.db.a.create(name='apple', newstr='booz')
2113         self.db.commit()
2114
2115
2116     def init_amodml(self):
2117         self.open_database()
2118         a = self.module.Class(self.db, "a", name=String(),
2119             newml=Multilink('a'))
2120         a.setkey('name')
2121         self.db.post_init()
2122
2123     def test_makeNewMultilink(self):
2124         self.init_a()
2125         aid = self.db.a.create(name='apple')
2126         self.assertEqual(self.db.a.lookup('apple'), aid)
2127         self.db.commit(); self.db.close()
2128
2129         # add a multilink prop
2130         self.init_amodml()
2131         bid = self.db.a.create(name='bear', newml=[aid])
2132         self.assertEqual(self.db.a.find(newml=aid), [bid])
2133         self.assertEqual(self.db.a.lookup('apple'), aid)
2134         self.db.commit(); self.db.close()
2135
2136         # check
2137         self.init_amodml()
2138         self.assertEqual(self.db.a.find(newml=aid), [bid])
2139         self.assertEqual(self.db.a.lookup('apple'), aid)
2140         self.assertEqual(self.db.a.lookup('bear'), bid)
2141
2142         # confirm journal's ok
2143         self.db.getjournal('a', aid)
2144         self.db.getjournal('a', bid)
2145
2146     def test_removeMultilink(self):
2147         # add a multilink prop
2148         self.init_amodml()
2149         aid = self.db.a.create(name='apple')
2150         bid = self.db.a.create(name='bear', newml=[aid])
2151         self.assertEqual(self.db.a.find(newml=aid), [bid])
2152         self.assertEqual(self.db.a.lookup('apple'), aid)
2153         self.assertEqual(self.db.a.lookup('bear'), bid)
2154         self.db.commit(); self.db.close()
2155
2156         # remove the multilink
2157         self.init_a()
2158         self.assertEqual(self.db.a.lookup('apple'), aid)
2159         self.assertEqual(self.db.a.lookup('bear'), bid)
2160
2161         # confirm journal's ok
2162         self.db.getjournal('a', aid)
2163         self.db.getjournal('a', bid)
2164
2165     def test_removeClass(self):
2166         self.init_ab()
2167         aid = self.db.a.create(name='apple')
2168         bid = self.db.b.create(name='bear')
2169         self.db.commit(); self.db.close()
2170
2171         # drop the b class
2172         self.init_a()
2173         self.assertEqual(self.db.a.get(aid, 'name'), 'apple')
2174         self.assertEqual(self.db.a.lookup('apple'), aid)
2175         self.db.commit(); self.db.close()
2176
2177         # now check we can recall the added class' items
2178         self.init_a()
2179         self.assertEqual(self.db.a.get(aid, 'name'), 'apple')
2180         self.assertEqual(self.db.a.lookup('apple'), aid)
2181
2182         # confirm journal's ok
2183         self.db.getjournal('a', aid)
2184
2185 class RDBMSTest:
2186     """ tests specific to RDBMS backends """
2187     def test_indexTest(self):
2188         self.assertEqual(self.db.sql_index_exists('_issue', '_issue_id_idx'), 1)
2189         self.assertEqual(self.db.sql_index_exists('_issue', '_issue_x_idx'), 0)
2190
2191 class FilterCacheTest(commonDBTest):
2192     def testFilteringTransitiveLinkCache(self):
2193         ae, filter, filter_iter = self.filteringSetupTransitiveSearch()
2194         ae, ufilter, ufilter_iter = self.iterSetup('user')
2195         # Need to make ceo his own (and first two users') supervisor
2196         self.db.user.set('1', supervisor = '3')
2197         self.db.user.set('2', supervisor = '3')
2198         self.db.user.set('3', supervisor = '3')
2199         # test bool value
2200         self.db.user.set('4', assignable = True)
2201         self.db.user.set('3', assignable = False)
2202         filt = self.db.issue.filter_iter
2203         ufilt = self.db.user.filter_iter
2204         user_result = \
2205             {  '1' : {'username': 'admin', 'assignable': None,
2206                       'supervisor': '3', 'realname': None, 'roles': 'Admin',
2207                       'creator': '1', 'age': None, 'actor': '1',
2208                       'address': None}
2209             ,  '2' : {'username': 'fred', 'assignable': None,
2210                       'supervisor': '3', 'realname': None, 'roles': 'User',
2211                       'creator': '1', 'age': None, 'actor': '1',
2212                       'address': 'fred@example.com'}
2213             ,  '3' : {'username': 'ceo', 'assignable': False,
2214                       'supervisor': '3', 'realname': None, 'roles': None,
2215                       'creator': '1', 'age': 129.0, 'actor': '1',
2216                       'address': None}
2217             ,  '4' : {'username': 'grouplead1', 'assignable': True,
2218                       'supervisor': '3', 'realname': None, 'roles': None,
2219                       'creator': '1', 'age': 29.0, 'actor': '1',
2220                       'address': None}
2221             ,  '5' : {'username': 'grouplead2', 'assignable': None,
2222                       'supervisor': '3', 'realname': None, 'roles': None,
2223                       'creator': '1', 'age': 29.0, 'actor': '1',
2224                       'address': None}
2225             ,  '6' : {'username': 'worker1', 'assignable': None,
2226                       'supervisor': '4', 'realname': None, 'roles': None,
2227                       'creator': '1', 'age': 25.0, 'actor': '1',
2228                       'address': None}
2229             ,  '7' : {'username': 'worker2', 'assignable': None,
2230                       'supervisor': '4', 'realname': None, 'roles': None,
2231                       'creator': '1', 'age': 24.0, 'actor': '1',
2232                       'address': None}
2233             ,  '8' : {'username': 'worker3', 'assignable': None,
2234                       'supervisor': '5', 'realname': None, 'roles': None,
2235                       'creator': '1', 'age': 23.0, 'actor': '1',
2236                       'address': None}
2237             ,  '9' : {'username': 'worker4', 'assignable': None,
2238                       'supervisor': '5', 'realname': None, 'roles': None,
2239                       'creator': '1', 'age': 22.0, 'actor': '1',
2240                       'address': None}
2241             , '10' : {'username': 'worker5', 'assignable': None,
2242                       'supervisor': '5', 'realname': None, 'roles': None,
2243                       'creator': '1', 'age': 21.0, 'actor': '1',
2244                       'address': None}
2245             }
2246         foo = date.Interval('-1d')
2247         issue_result = \
2248             { '1' : {'title': 'ts1', 'status': '2', 'assignedto': '6',
2249                      'priority': '3', 'messages' : ['4'], 'nosy' : ['4']}
2250             , '2' : {'title': 'ts2', 'status': '1', 'assignedto': '6',
2251                      'priority': '3', 'messages' : ['4'], 'nosy' : ['5']}
2252             , '3' : {'title': 'ts4', 'status': '2', 'assignedto': '7',
2253                      'priority': '3', 'messages' : ['5']}
2254             , '4' : {'title': 'ts5', 'status': '1', 'assignedto': '8',
2255                      'priority': '3', 'messages' : ['6']}
2256             , '5' : {'title': 'ts6', 'status': '2', 'assignedto': '9',
2257                      'priority': '3', 'messages' : ['7']}
2258             , '6' : {'title': 'ts7', 'status': '1', 'assignedto': '10',
2259                      'priority': '3', 'messages' : ['8'], 'foo' : None}
2260             , '7' : {'title': 'ts8', 'status': '2', 'assignedto': '10',
2261                      'priority': '3', 'messages' : ['8'], 'foo' : foo}
2262             , '8' : {'title': 'ts9', 'status': '1', 'assignedto': '10',
2263                      'priority': '3', 'messages' : ['7', '8']}
2264             }
2265         result = []
2266         self.db.clearCache()
2267         for id in ufilt(None, {}, [('+','supervisor.supervisor.supervisor'),
2268             ('-','supervisor.supervisor'), ('-','supervisor'),
2269             ('+','username')]):
2270             result.append(id)
2271             nodeid = id
2272             for x in range(4):
2273                 assert(('user', nodeid) in self.db.cache)
2274                 n = self.db.user.getnode(nodeid)
2275                 for k, v in user_result[nodeid].iteritems():
2276                     ae((k, n[k]), (k, v))
2277                 for k in 'creation', 'activity':
2278                     assert(n[k])
2279                 nodeid = n.supervisor
2280             self.db.clearCache()
2281         ae (result, ['8', '9', '10', '6', '7', '1', '3', '2', '4', '5'])
2282
2283         result = []
2284         self.db.clearCache()
2285         for id in filt(None, {},
2286             [('+','assignedto.supervisor.supervisor.supervisor'),
2287             ('+','assignedto.supervisor.supervisor'),
2288             ('-','assignedto.supervisor'), ('+','assignedto')]):
2289             result.append(id)
2290             assert(('issue', id) in self.db.cache)
2291             n = self.db.issue.getnode(id)
2292             for k, v in issue_result[id].iteritems():
2293                 ae((k, n[k]), (k, v))
2294             for k in 'creation', 'activity':
2295                 assert(n[k])
2296             nodeid = n.assignedto
2297             for x in range(4):
2298                 assert(('user', nodeid) in self.db.cache)
2299                 n = self.db.user.getnode(nodeid)
2300                 for k, v in user_result[nodeid].iteritems():
2301                     ae((k, n[k]), (k, v))
2302                 for k in 'creation', 'activity':
2303                     assert(n[k])
2304                 nodeid = n.supervisor
2305             self.db.clearCache()
2306         ae (result, ['4', '5', '6', '7', '8', '1', '2', '3'])
2307
2308
2309 class ClassicInitTest(unittest.TestCase):
2310     count = 0
2311     db = None
2312
2313     def setUp(self):
2314         ClassicInitTest.count = ClassicInitTest.count + 1
2315         self.dirname = '_test_init_%s'%self.count
2316         try:
2317             shutil.rmtree(self.dirname)
2318         except OSError, error:
2319             if error.errno not in (errno.ENOENT, errno.ESRCH): raise
2320
2321     def testCreation(self):
2322         ae = self.assertEqual
2323
2324         # set up and open a tracker
2325         tracker = setupTracker(self.dirname, self.backend)
2326         # open the database
2327         db = self.db = tracker.open('test')
2328
2329         # check the basics of the schema and initial data set
2330         l = db.priority.list()
2331         l.sort()
2332         ae(l, ['1', '2', '3', '4', '5'])
2333         l = db.status.list()
2334         l.sort()
2335         ae(l, ['1', '2', '3', '4', '5', '6', '7', '8'])
2336         l = db.keyword.list()
2337         ae(l, [])
2338         l = db.user.list()
2339         l.sort()
2340         ae(l, ['1', '2'])
2341         l = db.msg.list()
2342         ae(l, [])
2343         l = db.file.list()
2344         ae(l, [])
2345         l = db.issue.list()
2346         ae(l, [])
2347
2348     def tearDown(self):
2349         if self.db is not None:
2350             self.db.close()
2351         try:
2352             shutil.rmtree(self.dirname)
2353         except OSError, error:
2354             if error.errno not in (errno.ENOENT, errno.ESRCH): raise
2355
2356 class ConcurrentDBTest(ClassicInitTest):
2357     def testConcurrency(self):
2358         # The idea here is a read-modify-update cycle in the presence of
2359         # a cache that has to be properly handled. The same applies if
2360         # we extend a String or otherwise modify something that depends
2361         # on the previous value.
2362
2363         # set up and open a tracker
2364         tracker = setupTracker(self.dirname, self.backend)
2365         # open the database
2366         self.db = tracker.open('admin')
2367
2368         prio = '1'
2369         self.assertEqual(self.db.priority.get(prio, 'order'), 1.0)
2370         def inc(db):
2371             db.priority.set(prio, order=db.priority.get(prio, 'order') + 1)
2372
2373         inc(self.db)
2374
2375         db2 = tracker.open("admin")
2376         self.assertEqual(db2.priority.get(prio, 'order'), 1.0)
2377         db2.commit()
2378         self.db.commit()
2379         self.assertEqual(self.db.priority.get(prio, 'order'), 2.0)
2380
2381         inc(db2)
2382         db2.commit()
2383         db2.clearCache()
2384         self.assertEqual(db2.priority.get(prio, 'order'), 3.0)
2385         db2.close()
2386
2387
2388 # vim: set et sts=4 sw=4 :