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