tests/test_motion.py

   1 import motion
   2 import unittest
   3 import postgresql
   4 from unittest import TestCase
   5 from motion import app
   6 from datetime import datetime
   7
   8 app.config.update(
   9     DEBUGUSER = {},
  10     GROUP_PREFIX = {'127.0.0.1:5000': {'group1': 'g1', 'group2': 'g2'}},
  11     DURATION = {'127.0.0.1:5000':[3, 7, 14]},
  12     SERVER_NAME = '127.0.0.1:5000',
  13     MAX_PROXY=2
  14 )
  15
  16 app.config['TESTING'] = True
  17 app.config['DEBUG'] = False
  18
  19
  20 class BasicTest(TestCase):
  21
  22     def init_test(self):
  23         self.app = app.test_client()
  24         self.assertEqual(app.debug, False)
  25
  26         # reset database
  27         self.db_clear()
  28
  29     # functions to manipulate motions
  30     def createVote(self, user, motion, vote):
  31         return self.app.post(
  32             '/motion/' + motion +'/vote',
  33             environ_base={'USER_ROLES': user},
  34             data=dict(vote=vote)
  35         )
  36
  37
  38     def createMotion(self, user, motiontitle, motioncontent, days, category):
  39         return self.app.post(
  40             '/motion',
  41             environ_base={'USER_ROLES': user},
  42             data=dict(title=motiontitle, content=motioncontent, days=days, category=category)
  43         )
  44
  45     def cancelMotion(self, user, motion, reason):
  46         return self.app.post(
  47             '/motion/' + motion +'/cancel',
  48             environ_base={'USER_ROLES': user},
  49             data=dict(reason=reason)
  50         )
  51
  52     def finishMotion(self, user, motion):
  53         return self.app.post(
  54             '/motion/' + motion +'/finish',
  55             environ_base={'USER_ROLES': user}
  56         )
  57
  58     def addProxy(self, user, voter, proxy):
  59         return self.app.post(
  60             '/proxy/add',
  61             environ_base={'USER_ROLES': user},
  62             data=dict(voter=voter, proxy=proxy)
  63         )
  64
  65     def revokeProxy(self, user, id):
  66         return self.app.post(
  67             '/proxy/revoke',
  68             environ_base={'USER_ROLES': user},
  69             data=dict(id=id)
  70         )
  71
  72     def buildResultText(self, motiontext, yes, no, abstain):
  73         return '<p>'+motiontext+'</p></p>\n    <p>\nYes <span class=\"badge badge-pill badge-secondary\">'+str(yes)+'</span><br>'\
  74             + '\nNo <span class=\"badge badge-pill badge-secondary\">'+str(no)+'</span><br>'\
  75             + '\nAbstain <span class=\"badge badge-pill badge-secondary\">'+str(abstain)+'</span>'
  76
  77     # functions to clear database
  78     def db_clear(self):
  79         with postgresql.open(app.config.get("DATABASE"), user=app.config.get("USER"), password=app.config.get("PASSWORD")) as db:
  80             with app.open_resource('sql/schema.sql', mode='r') as f:
  81                 db.execute(f.read())
  82
  83     def db_sampledata(self):
  84         with postgresql.open(app.config.get("DATABASE"), user=app.config.get("USER"), password=app.config.get("PASSWORD")) as db:
  85             with app.open_resource('sql/sample_data.sql', mode='r') as f:
  86                 db.execute(f.read())
  87
  88
  89 # no specific rights required
  90 class GeneralTests(BasicTest):
  91
  92     def setUp(self):
  93         self.init_test()
  94         global user
  95         user = 'testuser/'
  96         self.db_sampledata()
  97
  98     def tearDown(self):
  99         pass
 100
 101     def test_main_page(self):
 102         response = self.app.get('/', environ_base={'USER_ROLES': user}, follow_redirects=True)
 103         self.assertEqual(response.status_code, 200)
 104
 105     def test_basic_results_data(self):
 106         result = self.app.get('/', environ_base={'USER_ROLES': user}, follow_redirects=True)
 107         testtext= '<div class="motion card" id="motion-3">\n  <div class="motion-title card-heading alert-warning">'\
 108             + '\n    <span class=\"title-text\">Motion C</span> (Canceled)\n    <span class=\"motion-type\">group1</span>'\
 109             + '\n    <div># g1.20200402.003'\
 110             + '\n    <a class="btn btn-primary" href="/motion/g1.20200402.003" role="button">Result</a>'\
 111             + '\n    </div>'\
 112             + '\n    <div class=\"date\">\n      <div>Proposed: 2020-04-02 21:47:24 (UTC) by User A</div>'\
 113             + '\n      <div>Canceled: 2020-04-03 21:48:24 (UTC) by User A</div></div>\n  </div>'\
 114             + '\n  <div class=\"card-body\">\n    <p><p>A third motion</p></p>'\
 115             + '\n    <p>\nYes <span class=\"badge badge-pill badge-secondary\">1</span><br>'\
 116             + '\nNo <span class=\"badge badge-pill badge-secondary\">0</span><br>'\
 117             + '\nAbstain <span class=\"badge badge-pill badge-secondary\">0</span><br>\n    </p>'\
 118             + '\n    <p>Cancelation reason: Entered with wrong text</p>\n  </div>\n</div>'
 119         self.assertIn(str.encode(testtext), result.data)
 120         testtext= '<div class="motion card" id="motion-2">\n  <div class="motion-title card-heading alert-danger">'\
 121             + '\n    <span class=\"title-text\">Motion B</span> (Finished)\n    <span class=\"motion-type\">group1</span>'\
 122             + '\n    <div># g1.20200402.002'\
 123             + '\n    <a class="btn btn-primary" href="/motion/g1.20200402.002" role="button">Result</a>'\
 124             + '\n    </div>'\
 125             + '\n    <div class=\"date\">\n      <div>Proposed: 2020-04-02 21:41:26 (UTC) by User A</div>'\
 126             + '\n      <div>Votes until: 2020-04-04 21:41:26 (UTC)</div></div>\n  </div>'\
 127             + '\n  <div class=\"card-body\">\n    <p><p>A second motion</p></p>'\
 128             + '\n    <p>\nYes <span class=\"badge badge-pill badge-secondary\">1</span><br>'\
 129             + '\nNo <span class=\"badge badge-pill badge-secondary\">2</span><br>'\
 130             + '\nAbstain <span class=\"badge badge-pill badge-secondary\">0</span><br>\n    </p>\n  </div>\n</div>\n'
 131         self.assertIn(str.encode(testtext), result.data)
 132         testtext= '<div class=\"motion card\" id=\"motion-1\">\n  <div class=\"motion-title card-heading alert-success\">'\
 133             + '\n    <span class=\"title-text\">Motion A</span> (Finished)\n    <span class=\"motion-type\">group1</span>'\
 134             + '\n    <div># g1.20200402.001'\
 135             + '\n    <a class="btn btn-primary" href="/motion/g1.20200402.001" role="button">Result</a>'\
 136             + '\n    </div>'\
 137             + '\n    <div class=\"date">\n      <div>Proposed: 2020-04-02 21:40:33 (UTC) by User A</div>'\
 138             + '\n      <div>Votes until: 2020-04-02 21:40:33 (UTC)</div></div>\n  </div>'\
 139             + '\n  <div class=\"card-body\">\n    <p><p>My special motion</p></p>'\
 140             + '\n    <p>\nYes <span class=\"badge badge-pill badge-secondary\">2</span><br>'\
 141             + '\nNo <span class=\"badge badge-pill badge-secondary\">1</span><br>'\
 142             + '\nAbstain <span class=\"badge badge-pill badge-secondary\">0</span><br>\n    </p>\n  </div>\n</div>\n</div>'
 143         self.assertIn(str.encode(testtext), result.data)
 144         testtext= 'Proxy management'
 145         self.assertNotIn(str.encode(testtext), result.data)
 146
 147         # start with second motion
 148         result = self.app.get('/', environ_base={'USER_ROLES': user}, query_string=dict(start=2))
 149         testtext= 'id=\"motion-3\">'
 150         self.assertNotIn(str.encode(testtext), result.data)
 151         testtext= 'id=\"motion-2">'
 152         self.assertIn(str.encode(testtext), result.data)
 153         testtext= 'id=\"motion-1\">'
 154         self.assertIn(str.encode(testtext), result.data)
 155
 156     def test_basic_results_data_details(self):
 157         motion='g1.20200402.002'
 158         result = self.app.get('/motion/' + motion, environ_base={'USER_ROLES': user}, follow_redirects=True)
 159         testtext= '<p>A second motion</p></p>\n  </div>\n</div>\n<a href=\"/?start=2#motion-2\" class=\"btn btn-primary\">Back</a>'
 160         self.assertIn(str.encode(testtext), result.data)
 161
 162     def test_vote(self):
 163         motion='g1.20200402.004'
 164         response = self.createVote(user, motion, 'yes')
 165         self.assertEqual(response.status_code, 403)
 166         self.assertIn(str.encode('Forbidden'), response.data)
 167
 168     def test_no_user(self):
 169         result = self.app.get('/', follow_redirects=True)
 170         self.assertEqual(result.status_code, 500)
 171         self.assertIn(str.encode('Server misconfigured'), result.data)
 172
 173     def test_user_invalid(self):
 174         result = self.app.get('/', environ_base={'USER_ROLES': '<invalid>/'}, follow_redirects=True)
 175         self.assertEqual(result.status_code, 403)
 176         self.assertIn(str.encode('Access denied'), result.data)
 177
 178     def test_basic_env(self):
 179         result = self.app.get('/', environ_base={'USER': 'testuser', 'ROLES':''}, follow_redirects=True)
 180         testtext= 'id=\"motion-3\">'
 181         self.assertIn(str.encode(testtext), result.data)
 182
 183     def test_basic_results_data_details_not_given(self):
 184         motion='g1.30190402.001'
 185         result = self.app.get('/motion/' + motion, environ_base={'USER_ROLES': user}, follow_redirects=True)
 186         self.assertEqual(result.status_code, 404)
 187         self.assertIn(str.encode('Error, Not found'), result.data)
 188
 189     def test_no_proxy(self):
 190         result = self.app.get('proxy', environ_base={'USER_ROLES': user}, follow_redirects=True)
 191         self.assertEqual(result.status_code, 403)
 192         self.assertIn(str.encode('Forbidden'), result.data)
 193
 194     def test_no_proxy_add(self):
 195         result = self.app.post('proxy/add', environ_base={'USER_ROLES': user}, follow_redirects=True)
 196         self.assertEqual(result.status_code, 403)
 197         self.assertIn(str.encode('Forbidden'), result.data)
 198
 199     def test_no_proxy_revoke(self):
 200         result = self.app.post('proxy/revoke', environ_base={'USER_ROLES': user}, follow_redirects=True)
 201         self.assertEqual(result.status_code, 403)
 202         self.assertIn(str.encode('Forbidden'), result.data)
 203
 204     def test_no_proxy_revokeAll(self):
 205         result = self.app.post('proxy/revokeall', environ_base={'USER_ROLES': user}, follow_redirects=True)
 206         self.assertEqual(result.status_code, 403)
 207         self.assertIn(str.encode('Forbidden'), result.data)
 208
 209 class VoterTests(BasicTest):
 210
 211     def setUp(self):
 212         self.init_test()
 213         global user
 214         user='testuser/vote:*'
 215         self.db_sampledata()
 216
 217     def tearDown(self):
 218         pass
 219
 220     def test_main_page(self):
 221         response = self.app.get('/', environ_base={'USER_ROLES': user}, follow_redirects=True)
 222         self.assertEqual(response.status_code, 200)
 223
 224     def test_home_data(self):
 225         result = self.app.get('/', environ_base={'USER_ROLES': user})
 226         self.assertNotIn("<select class=\"float form-control\" name=\"category\">", str(result.data) )
 227
 228     def test_vote_yes(self):
 229         motion='g1.20200402.004'
 230         response = self.createVote(user, motion, 'yes')
 231         self.assertEqual(response.status_code, 302)
 232         result = self.app.get('/', environ_base={'USER_ROLES': user})
 233         resulttext=self.buildResultText('A fourth motion', 1, 0, 0)
 234         result = self.app.get('/motion/' + motion, environ_base={'USER_ROLES': user}, follow_redirects=True)
 235         testtext= 'class=\"btn btn-success\" name=\"vote\" value="yes" id="vote-yes">yes</button>'
 236         self.assertIn(str.encode(testtext), result.data)
 237         testtext= 'class=\"btn btn-primary\" name=\"vote\" value=\"no\" id=\"vote-no\">no</button>'
 238         self.assertIn(str.encode(testtext), result.data)
 239         testtext= 'class=\"btn btn-primary\" name=\"vote\" value=\"abstain\" id=\"vote-abstain\">abstain</button>'
 240         self.assertIn(str.encode(testtext), result.data)
 241
 242     def test_vote_no(self):
 243         motion='g1.20200402.004'
 244         response = self.createVote(user, motion, 'no')
 245         self.assertEqual(response.status_code, 302)
 246         result = self.app.get('/', environ_base={'USER_ROLES': user})
 247         resulttext=self.buildResultText('A fourth motion', 0, 1, 0)
 248         self.assertIn(str.encode(resulttext), result.data)
 249         result = self.app.get('/motion/' + motion, environ_base={'USER_ROLES': user}, follow_redirects=True)
 250         testtext= 'class="btn btn-primary" name="vote\" value=\"yes\" id=\"vote-yes\">yes</button>'
 251         self.assertIn(str.encode(testtext), result.data)
 252         testtext= 'class=\"btn btn-success\" name=\"vote\" value=\"no\" id=\"vote-no\">no</button>'
 253         self.assertIn(str.encode(testtext), result.data)
 254         testtext= 'class=\"btn btn-primary\" name=\"vote\" value=\"abstain\" id=\"vote-abstain\">abstain</button>'
 255         self.assertIn(str.encode(testtext), result.data)
 256
 257     def test_vote_abstain(self):
 258         motion='g1.20200402.004'
 259         response = self.createVote(user, motion, 'abstain')
 260         self.assertEqual(response.status_code, 302)
 261         result = self.app.get('/', environ_base={'USER_ROLES': user})
 262         resulttext=self.buildResultText('A fourth motion', 0, 0, 1)
 263         self.assertIn(str.encode(resulttext), result.data)
 264         result = self.app.get('/motion/' + motion, environ_base={'USER_ROLES': user}, follow_redirects=True)
 265         testtext= 'class=\"btn btn-primary\" name=\"vote\" value=\"yes\" id=\"vote-yes\">yes</button>'
 266         self.assertIn(str.encode(testtext), result.data)
 267         testtext= 'class=\"btn btn-primary\" name=\"vote\" value=\"no\" id=\"vote-no\">no</button>'
 268         self.assertIn(str.encode(testtext), result.data)
 269         testtext= 'class=\"btn btn-success\" name=\"vote\" value=\"abstain\" id=\"vote-abstain\">abstain</button>'
 270         self.assertIn(str.encode(testtext), result.data)
 271
 272     def test_vote_change(self):
 273         motion='g1.20200402.004'
 274         response = self.createVote(user, motion, 'yes')
 275         self.assertEqual(response.status_code, 302)
 276         result = self.app.get('/', environ_base={'USER_ROLES': user})
 277         resulttext=self.buildResultText('A fourth motion', 1, 0, 0)
 278         self.assertIn(str.encode(resulttext), result.data)
 279         response = self.createVote(user, motion, 'no')
 280         self.assertEqual(response.status_code, 302)
 281         result = self.app.get('/', environ_base={'USER_ROLES': user})
 282         resulttext=self.buildResultText('A fourth motion', 0, 1, 0)
 283         self.assertIn(str.encode(resulttext), result.data)
 284         response = self.createVote(user, motion, 'abstain')
 285         self.assertEqual(response.status_code, 302)
 286         result = self.app.get('/', environ_base={'USER_ROLES': user})
 287         resulttext=self.buildResultText('A fourth motion', 0, 0, 1)
 288         self.assertIn(str.encode(resulttext), result.data)
 289
 290     def test_vote_group(self):
 291         motion='g1.20200402.004'
 292         response = self.createVote(user, motion, 'yes')
 293         self.assertEqual(response.status_code, 302)
 294
 295         motion='g1.20200402.004'
 296         user1='testuser/vote:group1'
 297         response = self.createVote(user1, motion, 'yes')
 298         self.assertEqual(response.status_code, 302)
 299
 300         motion='g1.20200402.004'
 301         user1='testuser/vote:group1 vote:group2'
 302         response = self.createVote(user1, motion, 'yes')
 303         self.assertEqual(response.status_code, 302)
 304
 305     def test_vote_wrong_group(self):
 306         motion='g1.20200402.004'
 307         user1='testuser/vote:group2'
 308         response = self.createVote(user1, motion, 'yes')
 309         self.assertEqual(response.status_code, 403)
 310         self.assertIn(str.encode('Forbidden'), response.data)
 311
 312     def test_vote_closed(self):
 313         motion='g1.20200402.002'
 314         response = self.createVote(user, motion, 'abstain')
 315         self.assertEqual(response.status_code, 403)
 316         self.assertIn(str.encode('Error, out of time'), response.data)
 317
 318     def test_vote_canceled(self):
 319         motion='g1.20200402.003'
 320         response = self.createVote(user, motion, 'abstain')
 321         self.assertEqual(response.status_code, 403)
 322         self.assertIn(str.encode('Error, motion was canceled'), response.data)
 323
 324     def test_vote_not_given(self):
 325         motion='g1.30190402.001'
 326         response = self.createVote(user, motion, 'abstain')
 327         self.assertEqual(response.status_code, 404)
 328         self.assertIn(str.encode('Error, Not found'), response.data)
 329
 330     def test_cancelMotion(self):
 331         motion='g1.20200402.004'
 332         reason="none"
 333         response = self.cancelMotion(user, motion, reason)
 334         self.assertEqual(response.status_code, 403)
 335         self.assertIn(str.encode('Forbidden'), response.data)
 336
 337     def test_finishMotion(self):
 338         motion='g1.20200402.004'
 339         response = self.finishMotion(user, motion)
 340         self.assertEqual(response.status_code, 403)
 341         self.assertIn(str.encode('Forbidden'), response.data)
 342
 343     def test_see_old_vote(self):
 344         motion='g1.20200402.002'
 345         result = self.app.get('/motion/' + motion, environ_base={'USER_ROLES': user}, follow_redirects=True)
 346         testtext= '<div>Proposed: 2020-04-02 21:41:26 (UTC) by User A</div>\n      <div>Votes until: 2020-04-04 21:41:26 (UTC)</div></div>'\
 347             + '\n  </div>\n  <div class="card-body">\n    <p><p>A second motion</p></p>\n  </div>\n</div>'\
 348             + '\n<a href="/?start=2#motion-2" class="btn btn-primary">Back</a>'
 349         self.assertIn(str.encode(testtext), result.data)
 350
 351     def test_createMotion(self):
 352         title='My Motion'
 353         content='My body'
 354         response = self.createMotion(user, title, content, '3', 'group1')
 355         self.assertEqual(response.status_code, 403)
 356         self.assertIn(str.encode('Forbidden'), response.data)
 357
 358
 359 class CreateMotionTests(BasicTest):
 360
 361     def setUp(self):
 362         self.init_test()
 363         global user
 364         user='testuser/vote:* create:* cancel:* finish:*'
 365         self.db_clear()
 366
 367     def tearDown(self):
 368         pass
 369
 370     def test_main_page(self):
 371         response = self.app.get('/', environ_base={'USER_ROLES': user}, follow_redirects=True)
 372         self.assertEqual(response.status_code, 200)
 373
 374     def test_home_data(self):
 375         result = self.app.get('/', environ_base={'USER_ROLES': user})
 376
 377         # assert the response data
 378         self.assertIn(b'User: testuser', result.data)
 379         self.assertIn("<select class=\"float form-control\" name=\"category\">", str(result.data) )
 380
 381     def test_createMotion(self):
 382         title='My Motion'
 383         content='My body'
 384         response = self.createMotion(user, title, content, '3', 'group1')
 385         self.assertEqual(response.status_code, 302)
 386         result = self.app.get('/', environ_base={'USER_ROLES': user})
 387         self.assertIn(str.encode(title), result.data)
 388         self.assertIn(str.encode(content), result.data)
 389         self.assertIn(str.encode('g1.'+datetime.today().strftime('%Y%m%d')+'.001'), result.data)
 390         testtext='<a class=\"btn btn-primary" href=\"/motion/g1.'+datetime.today().strftime('%Y%m%d')+'.001\" role=\"button\">Vote</a>'
 391         self.assertIn(str.encode(testtext), result.data)
 392
 393         title='My Motion1'
 394         content='My body1'
 395         response = self.createMotion(user, title, content, '3', 'group1')
 396         self.assertEqual(response.status_code, 302)
 397         result = self.app.get('/', environ_base={'USER_ROLES': user})
 398         self.assertIn(str.encode(title), result.data)
 399         self.assertIn(str.encode(content), result.data)
 400         self.assertIn(str.encode('g1.'+datetime.today().strftime('%Y%m%d')+'.002'), result.data)
 401
 402         title='My Motion2'
 403         content='My body2'
 404         response = self.createMotion(user, title, content, '3', 'group2')
 405         self.assertEqual(response.status_code, 302)
 406         result = self.app.get('/', environ_base={'USER_ROLES': user})
 407         self.assertIn(str.encode(title), result.data)
 408         self.assertIn(str.encode(content), result.data)
 409         self.assertIn(str.encode('g2.'+datetime.today().strftime('%Y%m%d')+'.001'), result.data)
 410
 411         title='My Motion3'
 412         content='My body3'
 413         user1='testuser/vote:* create:group1 cancel:*'
 414         response = self.createMotion(user1, title, content, '3', 'group1')
 415         self.assertEqual(response.status_code, 302)
 416
 417         title='My Motion4'
 418         content='My body4'
 419         user1='testuser/vote:* create:group1 create:group2 cancel:*'
 420         response = self.createMotion(user1, title, content, '3', 'group1')
 421         self.assertEqual(response.status_code, 302)
 422
 423
 424     def test_createMotionMarkdown(self):
 425         title='Markdown Test'
 426         content= 'MyMotionBody MD [text](https//domain.tld/link)'
 427         response = self.createMotion(user, title, content, '3', 'group1')
 428         self.assertEqual(response.status_code, 302)
 429         result = self.app.get('/', environ_base={'USER_ROLES': user})
 430         self.assertIn(str.encode(title), result.data)
 431         self.assertIn(b'MyMotionBody MD <a href=\"https//domain.tld/link\">text</a>', result.data)
 432
 433     def test_createMotionMarkdownDirectLink(self):
 434         title='Markdown Test Link'
 435         content='MyMotionBody MD <a href=\"https//domain.tld/link\">direct</a'
 436         response = self.createMotion(user, title, content, '3', 'group1')
 437         self.assertEqual(response.status_code, 302)
 438         result = self.app.get('/', environ_base={'USER_ROLES': user})
 439         self.assertIn(str.encode(title), result.data)
 440         self.assertIn(b'MyMotionBody MD &lt;a href="https//domain.tld/link"&gt;direct&lt;/a', result.data)
 441
 442     def test_createMotionMarkdownCombined(self):
 443         title='Markdown Test Link'
 444         content='Body [combined](https//domain.tld/link) <a href=\"https//domain.tld/link\">combined1</a'
 445         response = self.createMotion(user, title, content, '3', 'group1')
 446         self.assertEqual(response.status_code, 302)
 447         result = self.app.get('/', environ_base={'USER_ROLES': user})
 448         self.assertIn(str.encode(title), result.data)
 449         self.assertIn(b'Body <a href=\"https//domain.tld/link\">combined</a> &lt;a href="https//domain.tld/link"&gt;combined1&lt;/a', result.data)
 450
 451     def test_createMotionWrongDayLength(self):
 452         title='My Motion'
 453         content='My body'
 454         response = self.createMotion(user, title, content, '21', 'group1')
 455         self.assertEqual(response.status_code, 400)
 456         self.assertIn(str.encode('Error, invalid length'), response.data)
 457
 458     def test_createMotionMissingData(self):
 459         title=''
 460         content=''
 461         response = self.createMotion(user, title, content, '3', 'group1')
 462         self.assertEqual(response.status_code, 400)
 463         self.assertIn(str.encode('Error, missing title'), response.data)
 464         title='New Motion'
 465         response = self.createMotion(user, title, content, '3', 'group1')
 466         self.assertEqual(response.status_code, 400)
 467         self.assertIn(str.encode('Error, missing content'), response.data)
 468         title=''
 469         content='New Content'
 470         response = self.createMotion(user, title, content, '3', 'group1')
 471         self.assertEqual(response.status_code, 400)
 472         self.assertIn(str.encode('Error, missing title'), response.data)
 473
 474     def test_createMotionWrongGroup(self):
 475         title='My Motion'
 476         content='My body'
 477         response = self.createMotion(user, title, content, '3', 'test1')
 478         self.assertEqual(response.status_code, 403)
 479         self.assertIn(str.encode('Forbidden'), response.data)
 480
 481         user1='testuser/vote:* create:group1 cancel:*'
 482         response = self.createMotion(user1, title, content, '3', 'group2')
 483         self.assertEqual(response.status_code, 403)
 484         self.assertIn(str.encode('Forbidden'), response.data)
 485
 486     def test_cancelMotion(self):
 487         self.db_sampledata()
 488
 489         motion='g1.20200402.004'
 490         reason="none"
 491         response = self.cancelMotion(user, motion, reason)
 492         self.assertEqual(response.status_code, 500)
 493         self.assertIn(str.encode('Error, form requires reason'), response.data)
 494
 495         reason='cancel-test'
 496         response = self.cancelMotion(user, motion, reason)
 497         self.assertEqual(response.status_code, 302)
 498         result = self.app.get('/', environ_base={'USER_ROLES': user})
 499         self.assertIn(b'Cancelation reason: ' + str.encode(reason), result.data)
 500
 501         motion='g1.20190402.001'
 502         reason="none"
 503         response = self.cancelMotion(user, motion, reason)
 504         self.assertEqual(response.status_code, 404)
 505         self.assertIn(str.encode('Error, Not found'), response.data)
 506
 507         motion='g1.30200402.001'
 508         reason="cancel-test"
 509         response = self.cancelMotion(user, motion, reason)
 510         self.assertEqual(response.status_code, 404)
 511         self.assertIn(str.encode('Error, Not found'), response.data)
 512
 513         motion='g1.20200402.004'
 514         response = self.cancelMotion(user, motion, reason)
 515         self.assertEqual(response.status_code, 403)
 516         self.assertIn(str.encode('Error, motion was canceled'), response.data)
 517
 518     def test_finishMotion(self):
 519         self.db_sampledata()
 520
 521         motion='g1.20200402.004'
 522         response = self.finishMotion(user, motion)
 523         self.assertEqual(response.status_code, 302)
 524         result = self.app.get('/', environ_base={'USER_ROLES': user})
 525         self.assertIn(b'Motion D</span> (Finished)', result.data)
 526
 527         motion='g1.30190402.001'
 528         response = self.finishMotion(user, motion)
 529         self.assertEqual(response.status_code, 404)
 530         self.assertIn(str.encode('Error, Not found'), response.data)
 531
 532         motion='g1.20200402.001'
 533         response = self.finishMotion(user, motion)
 534         self.assertEqual(response.status_code, 403)
 535         self.assertIn(str.encode('Error, out of time'), response.data)
 536
 537 class AuditMotionTests(BasicTest):
 538
 539     def setUp(self):
 540         self.init_test()
 541         global user
 542         user='testuser/audit:*'
 543         self.db_sampledata()
 544
 545     def tearDown(self):
 546         pass
 547
 548     def test_see_old_vote(self):
 549         motion='g1.20200402.002'
 550         result = self.app.get('/motion/' + motion, environ_base={'USER_ROLES': user}, follow_redirects=True)
 551         testtext= '<div class="motion card" id="votes">\n  <div class="card-heading text-white bg-info">\n    Motion Votes\n  </div>'\
 552             + '\n  <div class="card-body">\n    <div>User A: yes</div>\n    <div>User B: no</div>'\
 553             + '\n    <div>User C: no</div>\n  </div>\n</div>\n<a href="/?start=2#motion-2" class="btn btn-primary">Back</a>'
 554         self.assertIn(str.encode(testtext), result.data)
 555
 556 class ProxyManagementTests(BasicTest):
 557
 558     def setUp(self):
 559         self.init_test()
 560         global user
 561         user='testuser/proxyadmin:*'
 562         self.db_sampledata()
 563
 564     def tearDown(self):
 565         pass
 566
 567     def test_see_proxy(self):
 568         result = self.app.get('proxy', environ_base={'USER_ROLES': user}, follow_redirects=True)
 569         testtext= 'div class="container">\n<form action="/proxy/add" method="POST">'
 570         self.assertIn(str.encode(testtext), result.data)
 571         testtext= 'proxy granted to:'
 572         self.assertNotIn(str.encode(testtext), result.data)
 573         testtext= 'holds proxy of:'
 574         self.assertNotIn(str.encode(testtext), result.data)
 575         testtext= '<select class="float form-control" name="voter">\n        '\
 576             + '<option>User A</option>\n        <option>User B</option>\n        '\
 577             + '<option>User C</option>\n        '\
 578             + '<option>testuser</option>\n      '\
 579             + '</select>\n'
 580         self.assertIn(str.encode(testtext), result.data)
 581         testtext= '<select class="float form-control" name="proxy">\n          '\
 582             + '<option>User A</option>\n          '\
 583             + '<option>User B</option>\n          '\
 584             + '<option>User C</option>\n          '\
 585             + '<option>testuser</option>\n      '\
 586             + '</select>\n'
 587         self.assertIn(str.encode(testtext), result.data)
 588         testtext= '<table>\n      '\
 589             + '<thead>\n        '\
 590             + '<th>Voter</th>\n        <th>Proxy</th>\n        <th></th>\n      </thead>\n    '\
 591             + '</table>\n'
 592         self.assertIn(str.encode(testtext), result.data)
 593         testtext= '<a class="nav-link" href="/proxy">Proxy management</a>'
 594         self.assertIn(str.encode(testtext), result.data)
 595
 596     def test_add_proxy(self):
 597         voter=''
 598         proxy=''
 599         response = self.addProxy(user, voter, proxy)
 600         self.assertEqual(response.status_code, 400)
 601         self.assertIn(str.encode('Error, voter equals proxy.'), response.data)
 602
 603         voter='User A'
 604         response = self.addProxy(user, voter, proxy)
 605         self.assertEqual(response.status_code, 400)
 606         self.assertIn(str.encode('Error, proxy not found.'), response.data)
 607
 608         voter='User Z'
 609         response = self.addProxy(user, voter, proxy)
 610         self.assertEqual(response.status_code, 400)
 611         self.assertIn(str.encode('Error, voter not found.'), response.data)
 612
 613         voter=''
 614         proxy='User B'
 615         response = self.addProxy(user, voter, proxy)
 616         self.assertEqual(response.status_code, 400)
 617         self.assertIn(str.encode('Error, voter not found.'), response.data)
 618
 619         voter='User B'
 620         proxy='User B'
 621         response = self.addProxy(user, voter, proxy)
 622         self.assertEqual(response.status_code, 400)
 623         self.assertIn(str.encode('Error, voter equals proxy.'), response.data)
 624
 625         voter='User A'
 626         proxy='User B'
 627         response = self.addProxy(user, voter, proxy)
 628         self.assertEqual(response.status_code, 302)
 629         result = self.app.get('proxy', environ_base={'USER_ROLES': user}, follow_redirects=True)
 630         testtext= '<form action="/proxy/revoke" method="POST">'
 631         self.assertIn(str.encode(testtext), result.data)
 632         testtext= '<table>\n      '\
 633             + '<thead>\n        '\
 634             + '<th>Voter</th>\n        '\
 635             + '<th>Proxy</th>\n        <th></th>\n      </thead>\n      '\
 636             + '<tr>\n        <td>User A</td>\n        <td>User B</td>\n        '\
 637             + '<td><button type="submit" class="btn btn-danger" name="id" value="1">Revoke</button></td>\n      '\
 638             + '</tr>\n    </table>\n'
 639         self.assertIn(str.encode(testtext), result.data)
 640
 641         response = self.addProxy(user, voter, proxy)
 642         self.assertEqual(response.status_code, 400)
 643         self.assertIn(str.encode('Error, proxy allready given.'), response.data)
 644
 645         voter='User A'
 646         proxy='User C'
 647         response = self.addProxy(user, voter, proxy)
 648         self.assertEqual(response.status_code, 400)
 649         self.assertIn(str.encode('Error, proxy allready given.'), response.data)
 650
 651         voter='User C'
 652         proxy='User B'
 653         response = self.addProxy(user, voter, proxy)
 654         self.assertEqual(response.status_code, 302)
 655         result = self.app.get('proxy', environ_base={'USER_ROLES': user}, follow_redirects=True)
 656         testtext= '<table>\n      '\
 657             + '<thead>\n        '\
 658             + '<th>Voter</th>\n        '\
 659             + '<th>Proxy</th>\n        <th></th>\n      </thead>\n      '\
 660             + '<tr>\n        <td>User A</td>\n        <td>User B</td>\n        '\
 661             + '<td><button type="submit" class="btn btn-danger" name="id" value="1">Revoke</button></td>\n      </tr>\n      '\
 662             + '<tr>\n        <td>User C</td>\n        <td>User B</td>\n        '\
 663             + '<td><button type="submit" class="btn btn-danger" name="id" value="2">Revoke</button></td>\n      '\
 664             + '</tr>\n    </table>\n'
 665         self.assertIn(str.encode(testtext), result.data)
 666         testtext= 'proxy granted to:'
 667         self.assertNotIn(str.encode(testtext), result.data)
 668         testtext= 'holds proxy of:'
 669         self.assertNotIn(str.encode(testtext), result.data)
 670
 671         voter='testuser'
 672         proxy='User B'
 673         response = self.addProxy(user, voter, proxy)
 674         self.assertEqual(response.status_code, 400)
 675         self.assertIn(str.encode('Error, Max proxy for \'User B\' reached.'), response.data)
 676
 677         voter='testuser'
 678         proxy='User A'
 679         response = self.addProxy(user, voter, proxy)
 680         self.assertEqual(response.status_code, 302)
 681         result = self.app.get('proxy', environ_base={'USER_ROLES': user}, follow_redirects=True)
 682         testtext= '<table>\n      '\
 683             + '<thead>\n        '\
 684             + '<th>Voter</th>\n        <th>Proxy</th>\n        <th></th>\n      </thead>\n      '\
 685             + '<tr>\n        <td>testuser</td>\n        <td>User A</td>\n        '\
 686             + '<td><button type="submit" class="btn btn-danger" name="id" value="3">Revoke</button></td>\n      </tr>\n      '\
 687             + '<tr>\n        <td>User A</td>\n        <td>User B</td>\n        '\
 688             + '<td><button type="submit" class="btn btn-danger" name="id" value="1">Revoke</button></td>\n      </tr>\n      '\
 689             + '<tr>\n        <td>User C</td>\n        <td>User B</td>\n        '\
 690             + '<td><button type="submit" class="btn btn-danger" name="id" value="2">Revoke</button></td>\n      '\
 691             + '</tr>\n    </table>\n'
 692         self.assertIn(str.encode(testtext), result.data)
 693         testtext= 'proxy granted to: User A\n'
 694         self.assertIn(str.encode(testtext), result.data)
 695         testtext= 'holds proxy of:'
 696         self.assertNotIn(str.encode(testtext), result.data)
 697
 698         voter='User B'
 699         proxy='testuser'
 700         response = self.addProxy(user, voter, proxy)
 701         self.assertEqual(response.status_code, 302)
 702         result = self.app.get('proxy', environ_base={'USER_ROLES': user}, follow_redirects=True)
 703         testtext= '<table>\n      '\
 704             + '<thead>\n        '\
 705             + '<th>Voter</th>\n        <th>Proxy</th>\n        <th></th>\n      </thead>\n      '\
 706             + '<tr>\n        <td>testuser</td>\n        <td>User A</td>\n        '\
 707             + '<td><button type="submit" class="btn btn-danger" name="id" value="3">Revoke</button></td>\n      </tr>\n      '\
 708             + '<tr>\n        <td>User A</td>\n        <td>User B</td>\n        '\
 709             + '<td><button type="submit" class="btn btn-danger" name="id" value="1">Revoke</button></td>\n      </tr>\n      '\
 710             + '<tr>\n        <td>User B</td>\n        <td>testuser</td>\n        '\
 711             + '<td><button type="submit" class="btn btn-danger" name="id" value="4">Revoke</button></td>\n      </tr>\n      '\
 712             + '<tr>\n        <td>User C</td>\n        <td>User B</td>\n        '\
 713             + '<td><button type="submit" class="btn btn-danger" name="id" value="2">Revoke</button></td>\n      '\
 714             + '</tr>\n    </table>\n'
 715         self.assertIn(str.encode(testtext), result.data)
 716         testtext= 'proxy granted to: User A\n'
 717         self.assertIn(str.encode(testtext), result.data)
 718         testtext= 'holds proxy of: User B\n'
 719         self.assertIn(str.encode(testtext), result.data)
 720
 721         response = self.revokeProxy(user, 4)
 722         self.assertEqual(response.status_code, 302)
 723         result = self.app.get('proxy', environ_base={'USER_ROLES': user}, follow_redirects=True)
 724         testtext= '<table>\n      '\
 725             + '<thead>\n        '\
 726             + '<th>Voter</th>\n        <th>Proxy</th>\n        <th></th>\n      </thead>\n      '\
 727             + '<tr>\n        <td>testuser</td>\n        <td>User A</td>\n        '\
 728             + '<td><button type="submit" class="btn btn-danger" name="id" value="3">Revoke</button></td>\n      </tr>\n      '\
 729             + '<tr>\n        <td>User A</td>\n        <td>User B</td>\n        '\
 730             + '<td><button type="submit" class="btn btn-danger" name="id" value="1">Revoke</button></td>\n      </tr>\n      '\
 731             + '<tr>\n        <td>User C</td>\n        <td>User B</td>\n        '\
 732             + '<td><button type="submit" class="btn btn-danger" name="id" value="2">Revoke</button></td>\n      '\
 733             + '</tr>\n    </table>\n'
 734         self.assertIn(str.encode(testtext), result.data)
 735         testtext= 'proxy granted to: User A\n'
 736         self.assertIn(str.encode(testtext), result.data)
 737         testtext= 'holds proxy of:'
 738         self.assertNotIn(str.encode(testtext), result.data)
 739
 740         response = self.revokeProxy(user, 3)
 741         self.assertEqual(response.status_code, 302)
 742         result = self.app.get('proxy', environ_base={'USER_ROLES': user}, follow_redirects=True)
 743         testtext= '<table>\n      '\
 744             + '<thead>\n        '\
 745             + '<th>Voter</th>\n        <th>Proxy</th>\n        <th></th>\n      </thead>\n      '\
 746             + '<tr>\n        <td>User A</td>\n        <td>User B</td>\n        '\
 747             + '<td><button type="submit" class="btn btn-danger" name="id" value="1">Revoke</button></td>\n      </tr>\n      '\
 748             + '<tr>\n        <td>User C</td>\n        <td>User B</td>\n        '\
 749             + '<td><button type="submit" class="btn btn-danger" name="id" value="2">Revoke</button></td>\n      '\
 750             + '</tr>\n    </table>\n'
 751         self.assertIn(str.encode(testtext), result.data)
 752         testtext= 'proxy granted to:'
 753         self.assertNotIn(str.encode(testtext), result.data)
 754         testtext= 'holds proxy of:'
 755         self.assertNotIn(str.encode(testtext), result.data)
 756
 757         result = self.app.post('proxy/revokeall', environ_base={'USER_ROLES': user}, follow_redirects=True)
 758         self.assertEqual(response.status_code, 302)
 759         result = self.app.get('proxy', environ_base={'USER_ROLES': user}, follow_redirects=True)
 760         testtext= '<table>\n      '\
 761             + '<thead>\n        '\
 762             + '<th>Voter</th>\n        <th>Proxy</th>\n        <th></th>\n      </thead>\n    '\
 763             + '</table>\n'
 764         self.assertIn(str.encode(testtext), result.data)
 765
 766
 767 if __name__ == "__main__":
 768     unittest.main()