test/test_cgi.py

   1 #
   2 # Copyright (c) 2003 Richard Jones, rjones@ekit-inc.com
   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 # This module is distributed in the hope that it will be useful,
   8 # but WITHOUT ANY WARRANTY; without even the implied warranty of
   9 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  10 #
  11 # $Id: test_cgi.py,v 1.21 2003-10-25 22:53:26 richard Exp $
  12
  13 import unittest, os, shutil, errno, sys, difflib, cgi, re
  14
  15 from roundup.cgi import client
  16 from roundup.cgi.client import FormError
  17 from roundup import init, instance, password, hyperdb, date
  18
  19 NEEDS_INSTANCE = 1
  20
  21 class FileUpload:
  22     def __init__(self, content, filename):
  23         self.content = content
  24         self.filename = filename
  25
  26 def makeForm(args):
  27     form = cgi.FieldStorage()
  28     for k,v in args.items():
  29         if type(v) is type([]):
  30             [form.list.append(cgi.MiniFieldStorage(k, x)) for x in v]
  31         elif isinstance(v, FileUpload):
  32             x = cgi.MiniFieldStorage(k, v.content)
  33             x.filename = v.filename
  34             form.list.append(x)
  35         else:
  36             form.list.append(cgi.MiniFieldStorage(k, v))
  37     return form
  38
  39 class config:
  40     TRACKER_NAME = 'testing testing'
  41     TRACKER_WEB = 'http://testing.testing/'
  42
  43 cm = client.clean_message
  44 class MessageTestCase(unittest.TestCase):
  45     def testCleanMessageOK(self):
  46         self.assertEqual(cm('<br>x<br />'), '<br>x<br />')
  47         self.assertEqual(cm('<i>x</i>'), '<i>x</i>')
  48         self.assertEqual(cm('<b>x</b>'), '<b>x</b>')
  49         self.assertEqual(cm('<a href="y">x</a>'),
  50             '<a href="y">x</a>')
  51         self.assertEqual(cm('<BR>x<BR />'), '<BR>x<BR />')
  52         self.assertEqual(cm('<I>x</I>'), '<I>x</I>')
  53         self.assertEqual(cm('<B>x</B>'), '<B>x</B>')
  54         self.assertEqual(cm('<A HREF="y">x</A>'),
  55             '<A HREF="y">x</A>')
  56
  57     def testCleanMessageBAD(self):
  58         self.assertEqual(cm('<script>x</script>'),
  59             '&lt;script&gt;x&lt;/script&gt;')
  60         self.assertEqual(cm('<iframe>x</iframe>'),
  61             '&lt;iframe&gt;x&lt;/iframe&gt;')
  62
  63 class FormTestCase(unittest.TestCase):
  64     def setUp(self):
  65         self.dirname = '_test_cgi_form'
  66         try:
  67             shutil.rmtree(self.dirname)
  68         except OSError, error:
  69             if error.errno not in (errno.ENOENT, errno.ESRCH): raise
  70         # create the instance
  71         init.install(self.dirname, 'templates/classic')
  72         init.write_select_db(self.dirname, 'anydbm')
  73         init.initialise(self.dirname, 'sekrit')
  74
  75         # check we can load the package
  76         self.instance = instance.open(self.dirname)
  77         # and open the database
  78         self.db = self.instance.open('admin')
  79         self.db.user.create(username='Chef', address='chef@bork.bork.bork',
  80             realname='Bork, Chef', roles='User')
  81         self.db.user.create(username='mary', address='mary@test',
  82             roles='User', realname='Contrary, Mary')
  83
  84         test = self.instance.dbinit.Class(self.db, "test",
  85             string=hyperdb.String(), number=hyperdb.Number(),
  86             boolean=hyperdb.Boolean(), link=hyperdb.Link('test'),
  87             multilink=hyperdb.Multilink('test'), date=hyperdb.Date(),
  88             interval=hyperdb.Interval())
  89
  90         # compile the labels re
  91         classes = '|'.join(self.db.classes.keys())
  92         self.FV_SPECIAL = re.compile(client.Client.FV_LABELS%classes,
  93             re.VERBOSE)
  94
  95     def parseForm(self, form, classname='test', nodeid=None):
  96         cl = client.Client(self.instance, None, {'PATH_INFO':'/'},
  97             makeForm(form))
  98         cl.classname = classname
  99         cl.nodeid = nodeid
 100         cl.db = self.db
 101         return cl.parsePropsFromForm()
 102
 103     def tearDown(self):
 104         self.db.close()
 105         try:
 106             shutil.rmtree(self.dirname)
 107         except OSError, error:
 108             if error.errno not in (errno.ENOENT, errno.ESRCH): raise
 109
 110     #
 111     # form label extraction
 112     #
 113     def tl(self, s, c, i, a, p):
 114         m = self.FV_SPECIAL.match(s)
 115         self.assertNotEqual(m, None)
 116         d = m.groupdict()
 117         self.assertEqual(d['classname'], c)
 118         self.assertEqual(d['id'], i)
 119         for action in 'required add remove link note file'.split():
 120             if a == action:
 121                 self.assertNotEqual(d[action], None)
 122             else:
 123                 self.assertEqual(d[action], None)
 124         self.assertEqual(d['propname'], p)
 125
 126     def testLabelMatching(self):
 127         self.tl('<propname>', None, None, None, '<propname>')
 128         self.tl(':required', None, None, 'required', None)
 129         self.tl(':confirm:<propname>', None, None, 'confirm', '<propname>')
 130         self.tl(':add:<propname>', None, None, 'add', '<propname>')
 131         self.tl(':remove:<propname>', None, None, 'remove', '<propname>')
 132         self.tl(':link:<propname>', None, None, 'link', '<propname>')
 133         self.tl('test1:<prop>', 'test', '1', None, '<prop>')
 134         self.tl('test1:required', 'test', '1', 'required', None)
 135         self.tl('test1:add:<prop>', 'test', '1', 'add', '<prop>')
 136         self.tl('test1:remove:<prop>', 'test', '1', 'remove', '<prop>')
 137         self.tl('test1:link:<prop>', 'test', '1', 'link', '<prop>')
 138         self.tl('test1:confirm:<prop>', 'test', '1', 'confirm', '<prop>')
 139         self.tl('test-1:<prop>', 'test', '-1', None, '<prop>')
 140         self.tl('test-1:required', 'test', '-1', 'required', None)
 141         self.tl('test-1:add:<prop>', 'test', '-1', 'add', '<prop>')
 142         self.tl('test-1:remove:<prop>', 'test', '-1', 'remove', '<prop>')
 143         self.tl('test-1:link:<prop>', 'test', '-1', 'link', '<prop>')
 144         self.tl('test-1:confirm:<prop>', 'test', '-1', 'confirm', '<prop>')
 145         self.tl(':note', None, None, 'note', None)
 146         self.tl(':file', None, None, 'file', None)
 147
 148     #
 149     # Empty form
 150     #
 151     def testNothing(self):
 152         self.assertEqual(self.parseForm({}), ({('test', None): {}}, []))
 153
 154     def testNothingWithRequired(self):
 155         self.assertRaises(FormError, self.parseForm, {':required': 'string'})
 156         self.assertRaises(FormError, self.parseForm,
 157             {':required': 'title,status', 'status':'1'}, 'issue')
 158         self.assertRaises(FormError, self.parseForm,
 159             {':required': ['title','status'], 'status':'1'}, 'issue')
 160         self.assertRaises(FormError, self.parseForm,
 161             {':required': 'status', 'status':''}, 'issue')
 162         self.assertRaises(FormError, self.parseForm,
 163             {':required': 'nosy', 'nosy':''}, 'issue')
 164
 165     #
 166     # Nonexistant edit
 167     #
 168     def testEditNonexistant(self):
 169         self.assertRaises(FormError, self.parseForm, {'boolean': ''},
 170             'test', '1')
 171
 172     #
 173     # String
 174     #
 175     def testEmptyString(self):
 176         self.assertEqual(self.parseForm({'string': ''}),
 177             ({('test', None): {}}, []))
 178         self.assertEqual(self.parseForm({'string': ' '}),
 179             ({('test', None): {}}, []))
 180         self.assertRaises(FormError, self.parseForm, {'string': ['', '']})
 181
 182     def testSetString(self):
 183         self.assertEqual(self.parseForm({'string': 'foo'}),
 184             ({('test', None): {'string': 'foo'}}, []))
 185         self.assertEqual(self.parseForm({'string': 'a\r\nb\r\n'}),
 186             ({('test', None): {'string': 'a\nb'}}, []))
 187         nodeid = self.db.issue.create(title='foo')
 188         self.assertEqual(self.parseForm({'title': 'foo'}, 'issue', nodeid),
 189             ({('issue', nodeid): {}}, []))
 190
 191     def testEmptyStringSet(self):
 192         nodeid = self.db.issue.create(title='foo')
 193         self.assertEqual(self.parseForm({'title': ''}, 'issue', nodeid),
 194             ({('issue', nodeid): {'title': None}}, []))
 195         nodeid = self.db.issue.create(title='foo')
 196         self.assertEqual(self.parseForm({'title': ' '}, 'issue', nodeid),
 197             ({('issue', nodeid): {'title': None}}, []))
 198
 199     def testFileUpload(self):
 200         file = FileUpload('foo', 'foo.txt')
 201         self.assertEqual(self.parseForm({'content': file}, 'file'),
 202             ({('file', None): {'content': 'foo', 'name': 'foo.txt',
 203             'type': 'text/plain'}}, []))
 204
 205     def testEditFileClassAttributes(self):
 206         self.assertEqual(self.parseForm({'name': 'foo.txt',
 207                                          'type': 'application/octet-stream'},
 208                                         'file'),
 209                          ({('file', None): {'name': 'foo.txt',
 210                                             'type': 'application/octet-stream'}},[]))
 211
 212     #
 213     # Link
 214     #
 215     def testEmptyLink(self):
 216         self.assertEqual(self.parseForm({'link': ''}),
 217             ({('test', None): {}}, []))
 218         self.assertEqual(self.parseForm({'link': ' '}),
 219             ({('test', None): {}}, []))
 220         self.assertRaises(FormError, self.parseForm, {'link': ['', '']})
 221         self.assertEqual(self.parseForm({'link': '-1'}),
 222             ({('test', None): {}}, []))
 223
 224     def testSetLink(self):
 225         self.assertEqual(self.parseForm({'status': 'unread'}, 'issue'),
 226             ({('issue', None): {'status': '1'}}, []))
 227         self.assertEqual(self.parseForm({'status': '1'}, 'issue'),
 228             ({('issue', None): {'status': '1'}}, []))
 229         nodeid = self.db.issue.create(status='unread')
 230         self.assertEqual(self.parseForm({'status': 'unread'}, 'issue', nodeid),
 231             ({('issue', nodeid): {}}, []))
 232
 233     def testUnsetLink(self):
 234         nodeid = self.db.issue.create(status='unread')
 235         self.assertEqual(self.parseForm({'status': '-1'}, 'issue', nodeid),
 236             ({('issue', nodeid): {'status': None}}, []))
 237
 238     def testInvalidLinkValue(self):
 239 # XXX This is not the current behaviour - should we enforce this?
 240 #        self.assertRaises(IndexError, self.parseForm,
 241 #            {'status': '4'}))
 242         self.assertRaises(FormError, self.parseForm, {'link': 'frozzle'})
 243         self.assertRaises(FormError, self.parseForm, {'status': 'frozzle'},
 244             'issue')
 245
 246     #
 247     # Multilink
 248     #
 249     def testEmptyMultilink(self):
 250         self.assertEqual(self.parseForm({'nosy': ''}),
 251             ({('test', None): {}}, []))
 252         self.assertEqual(self.parseForm({'nosy': ' '}),
 253             ({('test', None): {}}, []))
 254
 255     def testSetMultilink(self):
 256         self.assertEqual(self.parseForm({'nosy': '1'}, 'issue'),
 257             ({('issue', None): {'nosy': ['1']}}, []))
 258         self.assertEqual(self.parseForm({'nosy': 'admin'}, 'issue'),
 259             ({('issue', None): {'nosy': ['1']}}, []))
 260         self.assertEqual(self.parseForm({'nosy': ['1','2']}, 'issue'),
 261             ({('issue', None): {'nosy': ['1','2']}}, []))
 262         self.assertEqual(self.parseForm({'nosy': '1,2'}, 'issue'),
 263             ({('issue', None): {'nosy': ['1','2']}}, []))
 264         self.assertEqual(self.parseForm({'nosy': 'admin,2'}, 'issue'),
 265             ({('issue', None): {'nosy': ['1','2']}}, []))
 266
 267     def testMixedMultilink(self):
 268         form = cgi.FieldStorage()
 269         form.list.append(cgi.MiniFieldStorage('nosy', '1,2'))
 270         form.list.append(cgi.MiniFieldStorage('nosy', '3'))
 271         cl = client.Client(self.instance, None, {'PATH_INFO':'/'}, form)
 272         cl.classname = 'issue'
 273         cl.nodeid = None
 274         cl.db = self.db
 275         self.assertEqual(cl.parsePropsFromForm(),
 276             ({('issue', None): {'nosy': ['1','2', '3']}}, []))
 277
 278     def testEmptyMultilinkSet(self):
 279         nodeid = self.db.issue.create(nosy=['1','2'])
 280         self.assertEqual(self.parseForm({'nosy': ''}, 'issue', nodeid),
 281             ({('issue', nodeid): {'nosy': []}}, []))
 282         nodeid = self.db.issue.create(nosy=['1','2'])
 283         self.assertEqual(self.parseForm({'nosy': ' '}, 'issue', nodeid),
 284             ({('issue', nodeid): {'nosy': []}}, []))
 285         self.assertEqual(self.parseForm({'nosy': '1,2'}, 'issue', nodeid),
 286             ({('issue', nodeid): {}}, []))
 287
 288     def testInvalidMultilinkValue(self):
 289 # XXX This is not the current behaviour - should we enforce this?
 290 #        self.assertRaises(IndexError, self.parseForm,
 291 #            {'nosy': '4'}))
 292         self.assertRaises(FormError, self.parseForm, {'nosy': 'frozzle'},
 293             'issue')
 294         self.assertRaises(FormError, self.parseForm, {'nosy': '1,frozzle'},
 295             'issue')
 296         self.assertRaises(FormError, self.parseForm, {'multilink': 'frozzle'})
 297
 298     def testMultilinkAdd(self):
 299         nodeid = self.db.issue.create(nosy=['1'])
 300         # do nothing
 301         self.assertEqual(self.parseForm({':add:nosy': ''}, 'issue', nodeid),
 302             ({('issue', nodeid): {}}, []))
 303
 304         # do something ;)
 305         self.assertEqual(self.parseForm({':add:nosy': '2'}, 'issue', nodeid),
 306             ({('issue', nodeid): {'nosy': ['1','2']}}, []))
 307         self.assertEqual(self.parseForm({':add:nosy': '2,mary'}, 'issue',
 308             nodeid), ({('issue', nodeid): {'nosy': ['1','2','4']}}, []))
 309         self.assertEqual(self.parseForm({':add:nosy': ['2','3']}, 'issue',
 310             nodeid), ({('issue', nodeid): {'nosy': ['1','2','3']}}, []))
 311
 312     def testMultilinkAddNew(self):
 313         self.assertEqual(self.parseForm({':add:nosy': ['2','3']}, 'issue'),
 314             ({('issue', None): {'nosy': ['2','3']}}, []))
 315
 316     def testMultilinkRemove(self):
 317         nodeid = self.db.issue.create(nosy=['1','2'])
 318         # do nothing
 319         self.assertEqual(self.parseForm({':remove:nosy': ''}, 'issue', nodeid),
 320             ({('issue', nodeid): {}}, []))
 321
 322         # do something ;)
 323         self.assertEqual(self.parseForm({':remove:nosy': '1'}, 'issue',
 324             nodeid), ({('issue', nodeid): {'nosy': ['2']}}, []))
 325         self.assertEqual(self.parseForm({':remove:nosy': 'admin,2'},
 326             'issue', nodeid), ({('issue', nodeid): {'nosy': []}}, []))
 327         self.assertEqual(self.parseForm({':remove:nosy': ['1','2']},
 328             'issue', nodeid), ({('issue', nodeid): {'nosy': []}}, []))
 329
 330         # add and remove
 331         self.assertEqual(self.parseForm({':add:nosy': ['3'],
 332             ':remove:nosy': ['1','2']},
 333             'issue', nodeid), ({('issue', nodeid): {'nosy': ['3']}}, []))
 334
 335         # remove one that doesn't exist?
 336         self.assertRaises(FormError, self.parseForm, {':remove:nosy': '4'},
 337             'issue', nodeid)
 338
 339     def testMultilinkRetired(self):
 340         self.db.user.retire('2')
 341         self.assertEqual(self.parseForm({'nosy': ['2','3']}, 'issue'),
 342             ({('issue', None): {'nosy': ['2','3']}}, []))
 343         nodeid = self.db.issue.create(nosy=['1','2'])
 344         self.assertEqual(self.parseForm({':remove:nosy': '2'}, 'issue',
 345             nodeid), ({('issue', nodeid): {'nosy': ['1']}}, []))
 346         self.assertEqual(self.parseForm({':add:nosy': '3'}, 'issue', nodeid),
 347             ({('issue', nodeid): {'nosy': ['1','2','3']}}, []))
 348
 349     def testAddRemoveNonexistant(self):
 350         self.assertRaises(FormError, self.parseForm, {':remove:foo': '2'},
 351             'issue')
 352         self.assertRaises(FormError, self.parseForm, {':add:foo': '2'},
 353             'issue')
 354
 355     #
 356     # Password
 357     #
 358     def testEmptyPassword(self):
 359         self.assertEqual(self.parseForm({'password': ''}, 'user'),
 360             ({('user', None): {}}, []))
 361         self.assertEqual(self.parseForm({'password': ''}, 'user'),
 362             ({('user', None): {}}, []))
 363         self.assertRaises(FormError, self.parseForm, {'password': ['', '']},
 364             'user')
 365         self.assertRaises(FormError, self.parseForm, {'password': 'foo',
 366             ':confirm:password': ['', '']}, 'user')
 367
 368     def testSetPassword(self):
 369         self.assertEqual(self.parseForm({'password': 'foo',
 370             ':confirm:password': 'foo'}, 'user'),
 371             ({('user', None): {'password': 'foo'}}, []))
 372
 373     def testSetPasswordConfirmBad(self):
 374         self.assertRaises(FormError, self.parseForm, {'password': 'foo'},
 375             'user')
 376         self.assertRaises(FormError, self.parseForm, {'password': 'foo',
 377             ':confirm:password': 'bar'}, 'user')
 378
 379     def testEmptyPasswordNotSet(self):
 380         nodeid = self.db.user.create(username='1',
 381             password=password.Password('foo'))
 382         self.assertEqual(self.parseForm({'password': ''}, 'user', nodeid),
 383             ({('user', nodeid): {}}, []))
 384         nodeid = self.db.user.create(username='2',
 385             password=password.Password('foo'))
 386         self.assertEqual(self.parseForm({'password': '',
 387             ':confirm:password': ''}, 'user', nodeid),
 388             ({('user', nodeid): {}}, []))
 389
 390     #
 391     # Boolean
 392     #
 393     def testEmptyBoolean(self):
 394         self.assertEqual(self.parseForm({'boolean': ''}),
 395             ({('test', None): {}}, []))
 396         self.assertEqual(self.parseForm({'boolean': ' '}),
 397             ({('test', None): {}}, []))
 398         self.assertRaises(FormError, self.parseForm, {'boolean': ['', '']})
 399
 400     def testSetBoolean(self):
 401         self.assertEqual(self.parseForm({'boolean': 'yes'}),
 402             ({('test', None): {'boolean': 1}}, []))
 403         self.assertEqual(self.parseForm({'boolean': 'a\r\nb\r\n'}),
 404             ({('test', None): {'boolean': 0}}, []))
 405         nodeid = self.db.test.create(boolean=1)
 406         self.assertEqual(self.parseForm({'boolean': 'yes'}, 'test', nodeid),
 407             ({('test', nodeid): {}}, []))
 408         nodeid = self.db.test.create(boolean=0)
 409         self.assertEqual(self.parseForm({'boolean': 'no'}, 'test', nodeid),
 410             ({('test', nodeid): {}}, []))
 411
 412     def testEmptyBooleanSet(self):
 413         nodeid = self.db.test.create(boolean=0)
 414         self.assertEqual(self.parseForm({'boolean': ''}, 'test', nodeid),
 415             ({('test', nodeid): {'boolean': None}}, []))
 416         nodeid = self.db.test.create(boolean=1)
 417         self.assertEqual(self.parseForm({'boolean': ' '}, 'test', nodeid),
 418             ({('test', nodeid): {'boolean': None}}, []))
 419
 420     #
 421     # Number
 422     #
 423     def testEmptyNumber(self):
 424         self.assertEqual(self.parseForm({'number': ''}),
 425             ({('test', None): {}}, []))
 426         self.assertEqual(self.parseForm({'number': ' '}),
 427             ({('test', None): {}}, []))
 428         self.assertRaises(FormError, self.parseForm, {'number': ['', '']})
 429
 430     def testInvalidNumber(self):
 431         self.assertRaises(FormError, self.parseForm, {'number': 'hi, mum!'})
 432
 433     def testSetNumber(self):
 434         self.assertEqual(self.parseForm({'number': '1'}),
 435             ({('test', None): {'number': 1}}, []))
 436         self.assertEqual(self.parseForm({'number': '\n0\n'}),
 437             ({('test', None): {'number': 0}}, []))
 438         nodeid = self.db.test.create(number=1)
 439         self.assertEqual(self.parseForm({'number': '1'}, 'test', nodeid),
 440             ({('test', nodeid): {}}, []))
 441         nodeid = self.db.test.create(number=0)
 442         self.assertEqual(self.parseForm({'number': '0'}, 'test', nodeid),
 443             ({('test', nodeid): {}}, []))
 444
 445     def testEmptyNumberSet(self):
 446         nodeid = self.db.test.create(number=0)
 447         self.assertEqual(self.parseForm({'number': ''}, 'test', nodeid),
 448             ({('test', nodeid): {'number': None}}, []))
 449         nodeid = self.db.test.create(number=1)
 450         self.assertEqual(self.parseForm({'number': ' '}, 'test', nodeid),
 451             ({('test', nodeid): {'number': None}}, []))
 452
 453     #
 454     # Date
 455     #
 456     def testEmptyDate(self):
 457         self.assertEqual(self.parseForm({'date': ''}),
 458             ({('test', None): {}}, []))
 459         self.assertEqual(self.parseForm({'date': ' '}),
 460             ({('test', None): {}}, []))
 461         self.assertRaises(FormError, self.parseForm, {'date': ['', '']})
 462
 463     def testInvalidDate(self):
 464         self.assertRaises(FormError, self.parseForm, {'date': '12'})
 465
 466     def testSetDate(self):
 467         self.assertEqual(self.parseForm({'date': '2003-01-01'}),
 468             ({('test', None): {'date': date.Date('2003-01-01')}}, []))
 469         nodeid = self.db.test.create(date=date.Date('2003-01-01'))
 470         self.assertEqual(self.parseForm({'date': '2003-01-01'}, 'test',
 471             nodeid), ({('test', nodeid): {}}, []))
 472
 473     def testEmptyDateSet(self):
 474         nodeid = self.db.test.create(date=date.Date('.'))
 475         self.assertEqual(self.parseForm({'date': ''}, 'test', nodeid),
 476             ({('test', nodeid): {'date': None}}, []))
 477         nodeid = self.db.test.create(date=date.Date('1970-01-01.00:00:00'))
 478         self.assertEqual(self.parseForm({'date': ' '}, 'test', nodeid),
 479             ({('test', nodeid): {'date': None}}, []))
 480
 481     #
 482     # Test multiple items in form
 483     #
 484     def testMultiple(self):
 485         self.assertEqual(self.parseForm({'string': 'a', 'issue-1@title': 'b'}),
 486             ({('test', None): {'string': 'a'},
 487               ('issue', '-1'): {'title': 'b'}
 488              }, []))
 489
 490     def testMultipleExistingContext(self):
 491         nodeid = self.db.test.create()
 492         self.assertEqual(self.parseForm({'string': 'a', 'issue-1@title': 'b'},
 493             'test', nodeid),({('test', nodeid): {'string': 'a'},
 494             ('issue', '-1'): {'title': 'b'}}, []))
 495
 496     def testLinking(self):
 497         self.assertEqual(self.parseForm({
 498             'string': 'a',
 499             'issue-1@add@nosy': '1',
 500             'issue-2@link@superseder': 'issue-1',
 501             }),
 502             ({('test', None): {'string': 'a'},
 503               ('issue', '-1'): {'nosy': ['1']},
 504               ('issue', '-2'): {}
 505              },
 506              [('issue', '-2', 'superseder', [('issue', '-1')])
 507              ]
 508             )
 509         )
 510
 511     def testLinkBadDesignator(self):
 512         self.assertRaises(FormError, self.parseForm,
 513             {'test-1@link@link': 'blah'})
 514         self.assertRaises(FormError, self.parseForm,
 515             {'test-1@link@link': 'issue'})
 516
 517     def testLinkNotLink(self):
 518         self.assertRaises(FormError, self.parseForm,
 519             {'test-1@link@boolean': 'issue-1'})
 520         self.assertRaises(FormError, self.parseForm,
 521             {'test-1@link@string': 'issue-1'})
 522
 523     def testBackwardsCompat(self):
 524         res = self.parseForm({':note': 'spam'}, 'issue')
 525         date = res[0][('msg', '-1')]['date']
 526         self.assertEqual(res, ({('issue', None): {}, ('msg', '-1'):
 527             {'content': 'spam', 'author': '1', 'date': date}},
 528             [('issue', None, 'messages', [('msg', '-1')])]))
 529         file = FileUpload('foo', 'foo.txt')
 530         self.assertEqual(self.parseForm({':file': file}, 'issue'),
 531             ({('issue', None): {}, ('file', '-1'): {'content': 'foo',
 532             'name': 'foo.txt', 'type': 'text/plain'}},
 533             [('issue', None, 'files', [('file', '-1')])]))
 534
 535 def test_suite():
 536     suite = unittest.TestSuite()
 537     suite.addTest(unittest.makeSuite(FormTestCase))
 538     suite.addTest(unittest.makeSuite(MessageTestCase))
 539     return suite
 540
 541 if __name__ == '__main__':
 542     runner = unittest.TextTestRunner()
 543     unittest.main(testRunner=runner)
 544
 545 # vim: set filetype=python ts=4 sw=4 et si