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