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, voter):
  31         return self.app.post(
  32             '/motion/' + motion + '/vote/' + str(voter),
  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         global userid
  97         userid = 4
  98         self.db_sampledata()
  99
 100     def tearDown(self):
 101         pass
 102
 103     def test_main_page(self):
 104         response = self.app.get('/', environ_base={'USER_ROLES': user}, follow_redirects=True)
 105         self.assertEqual(response.status_code, 200)
 106
 107     def test_basic_results_data(self):
 108         result = self.app.get('/', environ_base={'USER_ROLES': user}, follow_redirects=True)
 109         testtext= '<div class="motion card" id="motion-3">\n  <div class="motion-title card-heading alert-warning">'\
 110             + '\n    <span class="title-text">Motion C</span> (Canceled)\n    <span class="motion-type">group1</span>'\
 111             + '\n    <div># g1.20200402.003'\
 112             + '\n    <a class="btn btn-primary" href="/motion/g1.20200402.003" role="button">Result</a>'\
 113             + '\n    </div>\n    <div class="date">'\
 114             + '\n      <div>Proposed: 2020-04-02 21:47:24 (UTC) by User A</div>'\
 115             + '\n      <div>Canceled: 2020-04-03 21:48:24 (UTC) by User A</div>\n     </div>\n  </div>'\
 116             + '\n  <div class="card-body">\n    <p><p>A third motion</p></p>'\
 117             + '\n    <p>\nYes <span class="badge badge-pill badge-secondary">1</span><br>'\
 118             + '\nNo <span class="badge badge-pill badge-secondary">0</span><br>'\
 119             + '\nAbstain <span class="badge badge-pill badge-secondary">0</span><br>\n    </p>'\
 120             + '\n    <p>Cancelation reason: Entered with wrong text</p>\n  </div>\n</div>\n'
 121         self.assertIn(str.encode(testtext), result.data)
 122         testtext= '<div class="motion card" id="motion-2">\n  <div class="motion-title card-heading alert-danger">'\
 123             + '\n    <span class="title-text">Motion B</span> (Finished)\n    <span class="motion-type">group1</span>'\
 124             + '\n    <div># g1.20200402.002'\
 125             + '\n    <a class="btn btn-primary" href="/motion/g1.20200402.002" role="button">Result</a>'\
 126             + '\n    </div>\n    <div class="date">\n      <div>Proposed: 2020-04-02 21:41:26 (UTC) by User A</div>'\
 127             + '\n      <div>Votes until: 2020-04-04 21:41:26 (UTC)</div>\n     </div>\n  </div>'\
 128             + '\n  <div class="card-body">\n    <p><p>A second motion</p></p>\n    <p>'\
 129             + '\nYes <span class="badge badge-pill badge-secondary">1</span><br>'\
 130             + '\nNo <span class="badge badge-pill badge-secondary">2</span><br>'\
 131             + '\nAbstain <span class="badge badge-pill badge-secondary">0</span><br>\n    </p>\n  </div>\n</div>\n'
 132         self.assertIn(str.encode(testtext), result.data)
 133         testtext= '<div class="motion card" id="motion-1">\n  <div class="motion-title card-heading alert-success">'\
 134             + '\n    <span class="title-text">Motion A</span> (Finished)\n    <span class="motion-type">group1</span>'\
 135             + '\n    <div># g1.20200402.001'\
 136             + '\n    <a class="btn btn-primary" href="/motion/g1.20200402.001" role="button">Result</a>'\
 137             + '\n    </div>\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>\n     </div>\n  </div>'\
 139             + '\n  <div class="card-body">\n    <p><p>My special motion</p></p>\n    <p>'\
 140             + '\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'
 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', userid)
 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         global userid
 216         userid = 4
 217         self.db_sampledata()
 218
 219     def tearDown(self):
 220         pass
 221
 222     def test_main_page(self):
 223         response = self.app.get('/', environ_base={'USER_ROLES': user}, follow_redirects=True)
 224         self.assertEqual(response.status_code, 200)
 225
 226     def test_home_data(self):
 227         result = self.app.get('/', environ_base={'USER_ROLES': user})
 228         self.assertNotIn("<select class=\"float form-control\" name=\"category\">", str(result.data) )
 229
 230     def test_vote_yes(self):
 231         motion='g1.20200402.004'
 232         response = self.createVote(user, motion, 'yes', userid)
 233         self.assertEqual(response.status_code, 302)
 234         result = self.app.get('/', environ_base={'USER_ROLES': user})
 235         resulttext=self.buildResultText('A fourth motion', 1, 0, 0)
 236         result = self.app.get('/motion/' + motion, environ_base={'USER_ROLES': user}, follow_redirects=True)
 237         testtext= 'class=\"btn btn-success\" name=\"vote\" value="yes" id="vote-yes">yes</button>'
 238         self.assertIn(str.encode(testtext), result.data)
 239         testtext= 'class=\"btn btn-primary\" name=\"vote\" value=\"no\" id=\"vote-no\">no</button>'
 240         self.assertIn(str.encode(testtext), result.data)
 241         testtext= 'class=\"btn btn-primary\" name=\"vote\" value=\"abstain\" id=\"vote-abstain\">abstain</button>'
 242         self.assertIn(str.encode(testtext), result.data)
 243
 244     def test_vote_no(self):
 245         motion='g1.20200402.004'
 246         response = self.createVote(user, motion, 'no', userid)
 247         self.assertEqual(response.status_code, 302)
 248         result = self.app.get('/', environ_base={'USER_ROLES': user})
 249         resulttext=self.buildResultText('A fourth motion', 0, 1, 0)
 250         self.assertIn(str.encode(resulttext), result.data)
 251         result = self.app.get('/motion/' + motion, environ_base={'USER_ROLES': user}, follow_redirects=True)
 252         testtext= 'class="btn btn-primary" name="vote\" value=\"yes\" id=\"vote-yes\">yes</button>'
 253         self.assertIn(str.encode(testtext), result.data)
 254         testtext= 'class=\"btn btn-success\" name=\"vote\" value=\"no\" id=\"vote-no\">no</button>'
 255         self.assertIn(str.encode(testtext), result.data)
 256         testtext= 'class=\"btn btn-primary\" name=\"vote\" value=\"abstain\" id=\"vote-abstain\">abstain</button>'
 257         self.assertIn(str.encode(testtext), result.data)
 258
 259     def test_vote_abstain(self):
 260         motion='g1.20200402.004'
 261         response = self.createVote(user, motion, 'abstain', userid)
 262         self.assertEqual(response.status_code, 302)
 263         result = self.app.get('/', environ_base={'USER_ROLES': user})
 264         resulttext=self.buildResultText('A fourth motion', 0, 0, 1)
 265         self.assertIn(str.encode(resulttext), result.data)
 266         result = self.app.get('/motion/' + motion, environ_base={'USER_ROLES': user}, follow_redirects=True)
 267         testtext= 'class=\"btn btn-primary\" name=\"vote\" value=\"yes\" id=\"vote-yes\">yes</button>'
 268         self.assertIn(str.encode(testtext), result.data)
 269         testtext= 'class=\"btn btn-primary\" name=\"vote\" value=\"no\" id=\"vote-no\">no</button>'
 270         self.assertIn(str.encode(testtext), result.data)
 271         testtext= 'class=\"btn btn-success\" name=\"vote\" value=\"abstain\" id=\"vote-abstain\">abstain</button>'
 272         self.assertIn(str.encode(testtext), result.data)
 273
 274     def test_vote_change(self):
 275         motion='g1.20200402.004'
 276         response = self.createVote(user, motion, 'yes', userid)
 277         self.assertEqual(response.status_code, 302)
 278         result = self.app.get('/', environ_base={'USER_ROLES': user})
 279         resulttext=self.buildResultText('A fourth motion', 1, 0, 0)
 280         self.assertIn(str.encode(resulttext), result.data)
 281         response = self.createVote(user, motion, 'no', userid)
 282         self.assertEqual(response.status_code, 302)
 283         result = self.app.get('/', environ_base={'USER_ROLES': user})
 284         resulttext=self.buildResultText('A fourth motion', 0, 1, 0)
 285         self.assertIn(str.encode(resulttext), result.data)
 286         response = self.createVote(user, motion, 'abstain', userid)
 287         self.assertEqual(response.status_code, 302)
 288         result = self.app.get('/', environ_base={'USER_ROLES': user})
 289         resulttext=self.buildResultText('A fourth motion', 0, 0, 1)
 290         self.assertIn(str.encode(resulttext), result.data)
 291
 292     def test_vote_group(self):
 293         motion='g1.20200402.004'
 294         response = self.createVote(user, motion, 'yes', userid)
 295         self.assertEqual(response.status_code, 302)
 296
 297         motion='g1.20200402.004'
 298         user1='testuser/vote:group1'
 299         response = self.createVote(user1, motion, 'yes', userid)
 300         self.assertEqual(response.status_code, 302)
 301
 302         motion='g1.20200402.004'
 303         user1='testuser/vote:group1 vote:group2'
 304         response = self.createVote(user1, motion, 'yes', userid)
 305         self.assertEqual(response.status_code, 302)
 306
 307     def test_vote_wrong_group(self):
 308         motion='g1.20200402.004'
 309         user1='testuser/vote:group2'
 310         response = self.createVote(user1, motion, 'yes', userid)
 311         self.assertEqual(response.status_code, 403)
 312         self.assertIn(str.encode('Forbidden'), response.data)
 313
 314     def test_vote_closed(self):
 315         motion='g1.20200402.002'
 316         response = self.createVote(user, motion, 'abstain', userid)
 317         self.assertEqual(response.status_code, 403)
 318         self.assertIn(str.encode('Error, out of time'), response.data)
 319
 320     def test_vote_canceled(self):
 321         motion='g1.20200402.003'
 322         response = self.createVote(user, motion, 'abstain', userid)
 323         self.assertEqual(response.status_code, 403)
 324         self.assertIn(str.encode('Error, motion was canceled'), response.data)
 325
 326     def test_vote_not_given(self):
 327         motion='g1.30190402.001'
 328         response = self.createVote(user, motion, 'abstain', userid)
 329         self.assertEqual(response.status_code, 404)
 330         self.assertIn(str.encode('Error, Not found'), response.data)
 331
 332     def test_cancelMotion(self):
 333         motion='g1.20200402.004'
 334         reason="none"
 335         response = self.cancelMotion(user, motion, reason)
 336         self.assertEqual(response.status_code, 403)
 337         self.assertIn(str.encode('Forbidden'), response.data)
 338
 339     def test_finishMotion(self):
 340         motion='g1.20200402.004'
 341         response = self.finishMotion(user, motion)
 342         self.assertEqual(response.status_code, 403)
 343         self.assertIn(str.encode('Forbidden'), response.data)
 344
 345     def test_see_old_vote(self):
 346         motion='g1.20200402.002'
 347         result = self.app.get('/motion/' + motion, environ_base={'USER_ROLES': user}, follow_redirects=True)
 348         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>'\
 349             + '\n     </div>\n  </div>\n  <div class="card-body">\n    <p><p>A second motion</p></p>\n  </div>\n</div>'\
 350             + '\n<a href="/?start=2#motion-2" class="btn btn-primary">Back</a>'
 351         self.assertIn(str.encode(testtext), result.data)
 352
 353     def test_createMotion(self):
 354         title='My Motion'
 355         content='My body'
 356         response = self.createMotion(user, title, content, '3', 'group1')
 357         self.assertEqual(response.status_code, 403)
 358         self.assertIn(str.encode('Forbidden'), response.data)
 359
 360
 361 class CreateMotionTests(BasicTest):
 362
 363     def setUp(self):
 364         self.init_test()
 365         global user
 366         user='testuser/vote:* create:* cancel:* finish:*'
 367         self.db_clear()
 368
 369     def tearDown(self):
 370         pass
 371
 372     def test_main_page(self):
 373         response = self.app.get('/', environ_base={'USER_ROLES': user}, follow_redirects=True)
 374         self.assertEqual(response.status_code, 200)
 375
 376     def test_home_data(self):
 377         result = self.app.get('/', environ_base={'USER_ROLES': user})
 378
 379         # assert the response data
 380         self.assertIn(b'User: testuser', result.data)
 381         self.assertIn("<select class=\"float form-control\" name=\"category\">", str(result.data) )
 382
 383     def test_createMotion(self):
 384         title='My Motion'
 385         content='My body'
 386         response = self.createMotion(user, title, content, '3', 'group1')
 387         self.assertEqual(response.status_code, 302)
 388         result = self.app.get('/', environ_base={'USER_ROLES': user})
 389         self.assertIn(str.encode(title), result.data)
 390         self.assertIn(str.encode(content), result.data)
 391         self.assertIn(str.encode('g1.'+datetime.today().strftime('%Y%m%d')+'.001'), result.data)
 392         testtext='<a class=\"btn btn-primary" href=\"/motion/g1.'+datetime.today().strftime('%Y%m%d')+'.001\" role=\"button\">Vote</a>'
 393         self.assertIn(str.encode(testtext), result.data)
 394
 395         title='My Motion1'
 396         content='My body1'
 397         response = self.createMotion(user, title, content, '3', 'group1')
 398         self.assertEqual(response.status_code, 302)
 399         result = self.app.get('/', environ_base={'USER_ROLES': user})
 400         self.assertIn(str.encode(title), result.data)
 401         self.assertIn(str.encode(content), result.data)
 402         self.assertIn(str.encode('g1.'+datetime.today().strftime('%Y%m%d')+'.002'), result.data)
 403
 404         title='My Motion2'
 405         content='My body2'
 406         response = self.createMotion(user, title, content, '3', 'group2')
 407         self.assertEqual(response.status_code, 302)
 408         result = self.app.get('/', environ_base={'USER_ROLES': user})
 409         self.assertIn(str.encode(title), result.data)
 410         self.assertIn(str.encode(content), result.data)
 411         self.assertIn(str.encode('g2.'+datetime.today().strftime('%Y%m%d')+'.001'), result.data)
 412
 413         title='My Motion3'
 414         content='My body3'
 415         user1='testuser/vote:* create:group1 cancel:*'
 416         response = self.createMotion(user1, title, content, '3', 'group1')
 417         self.assertEqual(response.status_code, 302)
 418
 419         title='My Motion4'
 420         content='My body4'
 421         user1='testuser/vote:* create:group1 create:group2 cancel:*'
 422         response = self.createMotion(user1, title, content, '3', 'group1')
 423         self.assertEqual(response.status_code, 302)
 424
 425
 426     def test_createMotionMarkdown(self):
 427         title='Markdown Test'
 428         content= 'MyMotionBody MD [text](https//domain.tld/link)'
 429         response = self.createMotion(user, title, content, '3', 'group1')
 430         self.assertEqual(response.status_code, 302)
 431         result = self.app.get('/', environ_base={'USER_ROLES': user})
 432         self.assertIn(str.encode(title), result.data)
 433         self.assertIn(b'MyMotionBody MD <a href=\"https//domain.tld/link\">text</a>', result.data)
 434
 435     def test_createMotionMarkdownDirectLink(self):
 436         title='Markdown Test Link'
 437         content='MyMotionBody MD <a href=\"https//domain.tld/link\">direct</a'
 438         response = self.createMotion(user, title, content, '3', 'group1')
 439         self.assertEqual(response.status_code, 302)
 440         result = self.app.get('/', environ_base={'USER_ROLES': user})
 441         self.assertIn(str.encode(title), result.data)
 442         self.assertIn(b'MyMotionBody MD &lt;a href="https//domain.tld/link"&gt;direct&lt;/a', result.data)
 443
 444     def test_createMotionMarkdownCombined(self):
 445         title='Markdown Test Link'
 446         content='Body [combined](https//domain.tld/link) <a href=\"https//domain.tld/link\">combined1</a'
 447         response = self.createMotion(user, title, content, '3', 'group1')
 448         self.assertEqual(response.status_code, 302)
 449         result = self.app.get('/', environ_base={'USER_ROLES': user})
 450         self.assertIn(str.encode(title), result.data)
 451         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)
 452
 453     def test_createMotionWrongDayLength(self):
 454         title='My Motion'
 455         content='My body'
 456         response = self.createMotion(user, title, content, '21', 'group1')
 457         self.assertEqual(response.status_code, 400)
 458         self.assertIn(str.encode('Error, invalid length'), response.data)
 459
 460     def test_createMotionMissingData(self):
 461         title=''
 462         content=''
 463         response = self.createMotion(user, title, content, '3', 'group1')
 464         self.assertEqual(response.status_code, 400)
 465         self.assertIn(str.encode('Error, missing title'), response.data)
 466         title='New Motion'
 467         response = self.createMotion(user, title, content, '3', 'group1')
 468         self.assertEqual(response.status_code, 400)
 469         self.assertIn(str.encode('Error, missing content'), response.data)
 470         title=''
 471         content='New Content'
 472         response = self.createMotion(user, title, content, '3', 'group1')
 473         self.assertEqual(response.status_code, 400)
 474         self.assertIn(str.encode('Error, missing title'), response.data)
 475
 476     def test_createMotionWrongGroup(self):
 477         title='My Motion'
 478         content='My body'
 479         response = self.createMotion(user, title, content, '3', 'test1')
 480         self.assertEqual(response.status_code, 403)
 481         self.assertIn(str.encode('Forbidden'), response.data)
 482
 483         user1='testuser/vote:* create:group1 cancel:*'
 484         response = self.createMotion(user1, title, content, '3', 'group2')
 485         self.assertEqual(response.status_code, 403)
 486         self.assertIn(str.encode('Forbidden'), response.data)
 487
 488     def test_cancelMotion(self):
 489         self.db_sampledata()
 490
 491         motion='g1.20200402.004'
 492         reason="none"
 493         response = self.cancelMotion(user, motion, reason)
 494         self.assertEqual(response.status_code, 500)
 495         self.assertIn(str.encode('Error, form requires reason'), response.data)
 496
 497         reason='cancel-test'
 498         response = self.cancelMotion(user, motion, reason)
 499         self.assertEqual(response.status_code, 302)
 500         result = self.app.get('/', environ_base={'USER_ROLES': user})
 501         self.assertIn(b'Cancelation reason: ' + str.encode(reason), result.data)
 502
 503         motion='g1.20190402.001'
 504         reason="none"
 505         response = self.cancelMotion(user, motion, reason)
 506         self.assertEqual(response.status_code, 404)
 507         self.assertIn(str.encode('Error, Not found'), response.data)
 508
 509         motion='g1.30200402.001'
 510         reason="cancel-test"
 511         response = self.cancelMotion(user, motion, reason)
 512         self.assertEqual(response.status_code, 404)
 513         self.assertIn(str.encode('Error, Not found'), response.data)
 514
 515         motion='g1.20200402.004'
 516         response = self.cancelMotion(user, motion, reason)
 517         self.assertEqual(response.status_code, 403)
 518         self.assertIn(str.encode('Error, motion was canceled'), response.data)
 519
 520     def test_finishMotion(self):
 521         self.db_sampledata()
 522
 523         motion='g1.20200402.004'
 524         response = self.finishMotion(user, motion)
 525         self.assertEqual(response.status_code, 302)
 526         result = self.app.get('/', environ_base={'USER_ROLES': user})
 527         self.assertIn(b'Motion D</span> (Finished)', result.data)
 528
 529         motion='g1.30190402.001'
 530         response = self.finishMotion(user, motion)
 531         self.assertEqual(response.status_code, 404)
 532         self.assertIn(str.encode('Error, Not found'), response.data)
 533
 534         motion='g1.20200402.001'
 535         response = self.finishMotion(user, motion)
 536         self.assertEqual(response.status_code, 403)
 537         self.assertIn(str.encode('Error, out of time'), response.data)
 538
 539 class AuditMotionTests(BasicTest):
 540
 541     def setUp(self):
 542         self.init_test()
 543         global user
 544         user='testuser/audit:*'
 545         self.db_sampledata()
 546
 547     def tearDown(self):
 548         pass
 549
 550     def test_see_old_vote(self):
 551         motion='g1.20200402.002'
 552         result = self.app.get('/motion/' + motion, environ_base={'USER_ROLES': user}, follow_redirects=True)
 553         testtext= '<div class="motion card" id="votes">\n  <div class="card-heading text-white bg-info">\n    Motion Votes\n  </div>'\
 554             + '\n  <div class="card-body">\n    <div>User A: yes</div>\n    <div>User B: no</div>'\
 555             + '\n    <div>User C: no</div>\n  </div>\n</div>\n<a href="/?start=2#motion-2" class="btn btn-primary">Back</a>'
 556         self.assertIn(str.encode(testtext), result.data)
 557
 558 class ProxyManagementTests(BasicTest):
 559
 560     def setUp(self):
 561         self.init_test()
 562         global user
 563         user='testuser/proxyadmin:*'
 564         self.db_sampledata()
 565
 566     def tearDown(self):
 567         pass
 568
 569     def test_see_proxy(self):
 570         result = self.app.get('proxy', environ_base={'USER_ROLES': user}, follow_redirects=True)
 571         testtext= 'div class="container">\n<form action="/proxy/add" method="POST">'
 572         self.assertIn(str.encode(testtext), result.data)
 573         testtext= 'proxy granted to:'
 574         self.assertNotIn(str.encode(testtext), result.data)
 575         testtext= 'holds proxy of:'
 576         self.assertNotIn(str.encode(testtext), result.data)
 577         testtext= '<select class="float form-control" name="voter">\n        '\
 578             + '<option>User A</option>\n        <option>User B</option>\n        '\
 579             + '<option>User C</option>\n        '\
 580             + '<option>testuser</option>\n      '\
 581             + '</select>\n'
 582         self.assertIn(str.encode(testtext), result.data)
 583         testtext= '<select class="float form-control" name="proxy">\n          '\
 584             + '<option>User A</option>\n          '\
 585             + '<option>User B</option>\n          '\
 586             + '<option>User C</option>\n          '\
 587             + '<option>testuser</option>\n      '\
 588             + '</select>\n'
 589         self.assertIn(str.encode(testtext), result.data)
 590         testtext= '<table>\n      '\
 591             + '<thead>\n        '\
 592             + '<th>Voter</th>\n        <th>Proxy</th>\n        <th></th>\n      </thead>\n    '\
 593             + '</table>\n'
 594         self.assertIn(str.encode(testtext), result.data)
 595         testtext= '<a class="nav-link" href="/proxy">Proxy management</a>'
 596         self.assertIn(str.encode(testtext), result.data)
 597
 598     def test_add_proxy(self):
 599         voter=''
 600         proxy=''
 601         response = self.addProxy(user, voter, proxy)
 602         self.assertEqual(response.status_code, 400)
 603         self.assertIn(str.encode('Error, voter equals proxy.'), response.data)
 604
 605         voter='User A'
 606         response = self.addProxy(user, voter, proxy)
 607         self.assertEqual(response.status_code, 400)
 608         self.assertIn(str.encode('Error, proxy not found.'), response.data)
 609
 610         voter='User Z'
 611         response = self.addProxy(user, voter, proxy)
 612         self.assertEqual(response.status_code, 400)
 613         self.assertIn(str.encode('Error, voter not found.'), response.data)
 614
 615         voter=''
 616         proxy='User B'
 617         response = self.addProxy(user, voter, proxy)
 618         self.assertEqual(response.status_code, 400)
 619         self.assertIn(str.encode('Error, voter not found.'), response.data)
 620
 621         voter='User B'
 622         proxy='User B'
 623         response = self.addProxy(user, voter, proxy)
 624         self.assertEqual(response.status_code, 400)
 625         self.assertIn(str.encode('Error, voter equals proxy.'), response.data)
 626
 627         voter='User A'
 628         proxy='User B'
 629         response = self.addProxy(user, voter, proxy)
 630         self.assertEqual(response.status_code, 302)
 631         result = self.app.get('proxy', environ_base={'USER_ROLES': user}, follow_redirects=True)
 632         testtext= '<form action="/proxy/revoke" method="POST">'
 633         self.assertIn(str.encode(testtext), result.data)
 634         testtext= '<table>\n      '\
 635             + '<thead>\n        '\
 636             + '<th>Voter</th>\n        '\
 637             + '<th>Proxy</th>\n        <th></th>\n      </thead>\n      '\
 638             + '<tr>\n        <td>User A</td>\n        <td>User B</td>\n        '\
 639             + '<td><button type="submit" class="btn btn-danger" name="id" value="1">Revoke</button></td>\n      '\
 640             + '</tr>\n    </table>\n'
 641         self.assertIn(str.encode(testtext), result.data)
 642
 643         response = self.addProxy(user, voter, proxy)
 644         self.assertEqual(response.status_code, 400)
 645         self.assertIn(str.encode('Error, proxy allready given.'), response.data)
 646
 647         voter='User A'
 648         proxy='User C'
 649         response = self.addProxy(user, voter, proxy)
 650         self.assertEqual(response.status_code, 400)
 651         self.assertIn(str.encode('Error, proxy allready given.'), response.data)
 652
 653         voter='User C'
 654         proxy='User B'
 655         response = self.addProxy(user, voter, proxy)
 656         self.assertEqual(response.status_code, 302)
 657         result = self.app.get('proxy', environ_base={'USER_ROLES': user}, follow_redirects=True)
 658         testtext= '<table>\n      '\
 659             + '<thead>\n        '\
 660             + '<th>Voter</th>\n        '\
 661             + '<th>Proxy</th>\n        <th></th>\n      </thead>\n      '\
 662             + '<tr>\n        <td>User A</td>\n        <td>User B</td>\n        '\
 663             + '<td><button type="submit" class="btn btn-danger" name="id" value="1">Revoke</button></td>\n      </tr>\n      '\
 664             + '<tr>\n        <td>User C</td>\n        <td>User B</td>\n        '\
 665             + '<td><button type="submit" class="btn btn-danger" name="id" value="2">Revoke</button></td>\n      '\
 666             + '</tr>\n    </table>\n'
 667         self.assertIn(str.encode(testtext), result.data)
 668         testtext= 'proxy granted to:'
 669         self.assertNotIn(str.encode(testtext), result.data)
 670         testtext= 'holds proxy of:'
 671         self.assertNotIn(str.encode(testtext), result.data)
 672
 673         voter='testuser'
 674         proxy='User B'
 675         response = self.addProxy(user, voter, proxy)
 676         self.assertEqual(response.status_code, 400)
 677         self.assertIn(str.encode('Error, Max proxy for \'User B\' reached.'), response.data)
 678
 679         voter='testuser'
 680         proxy='User A'
 681         response = self.addProxy(user, voter, proxy)
 682         self.assertEqual(response.status_code, 302)
 683         result = self.app.get('proxy', environ_base={'USER_ROLES': user}, follow_redirects=True)
 684         testtext= '<table>\n      '\
 685             + '<thead>\n        '\
 686             + '<th>Voter</th>\n        <th>Proxy</th>\n        <th></th>\n      </thead>\n      '\
 687             + '<tr>\n        <td>testuser</td>\n        <td>User A</td>\n        '\
 688             + '<td><button type="submit" class="btn btn-danger" name="id" value="3">Revoke</button></td>\n      </tr>\n      '\
 689             + '<tr>\n        <td>User A</td>\n        <td>User B</td>\n        '\
 690             + '<td><button type="submit" class="btn btn-danger" name="id" value="1">Revoke</button></td>\n      </tr>\n      '\
 691             + '<tr>\n        <td>User C</td>\n        <td>User B</td>\n        '\
 692             + '<td><button type="submit" class="btn btn-danger" name="id" value="2">Revoke</button></td>\n      '\
 693             + '</tr>\n    </table>\n'
 694         self.assertIn(str.encode(testtext), result.data)
 695         testtext= 'proxy granted to: User A\n'
 696         self.assertIn(str.encode(testtext), result.data)
 697         testtext= 'holds proxy of:'
 698         self.assertNotIn(str.encode(testtext), result.data)
 699
 700         voter='User B'
 701         proxy='testuser'
 702         response = self.addProxy(user, voter, proxy)
 703         self.assertEqual(response.status_code, 302)
 704         result = self.app.get('proxy', environ_base={'USER_ROLES': user}, follow_redirects=True)
 705         testtext= '<table>\n      '\
 706             + '<thead>\n        '\
 707             + '<th>Voter</th>\n        <th>Proxy</th>\n        <th></th>\n      </thead>\n      '\
 708             + '<tr>\n        <td>testuser</td>\n        <td>User A</td>\n        '\
 709             + '<td><button type="submit" class="btn btn-danger" name="id" value="3">Revoke</button></td>\n      </tr>\n      '\
 710             + '<tr>\n        <td>User A</td>\n        <td>User B</td>\n        '\
 711             + '<td><button type="submit" class="btn btn-danger" name="id" value="1">Revoke</button></td>\n      </tr>\n      '\
 712             + '<tr>\n        <td>User B</td>\n        <td>testuser</td>\n        '\
 713             + '<td><button type="submit" class="btn btn-danger" name="id" value="4">Revoke</button></td>\n      </tr>\n      '\
 714             + '<tr>\n        <td>User C</td>\n        <td>User B</td>\n        '\
 715             + '<td><button type="submit" class="btn btn-danger" name="id" value="2">Revoke</button></td>\n      '\
 716             + '</tr>\n    </table>\n'
 717         self.assertIn(str.encode(testtext), result.data)
 718         testtext= 'proxy granted to: User A\n'
 719         self.assertIn(str.encode(testtext), result.data)
 720         testtext= 'holds proxy of: User B\n'
 721         self.assertIn(str.encode(testtext), result.data)
 722
 723         response = self.revokeProxy(user, userid)
 724         self.assertEqual(response.status_code, 302)
 725         result = self.app.get('proxy', environ_base={'USER_ROLES': user}, follow_redirects=True)
 726         testtext= '<table>\n      '\
 727             + '<thead>\n        '\
 728             + '<th>Voter</th>\n        <th>Proxy</th>\n        <th></th>\n      </thead>\n      '\
 729             + '<tr>\n        <td>testuser</td>\n        <td>User A</td>\n        '\
 730             + '<td><button type="submit" class="btn btn-danger" name="id" value="3">Revoke</button></td>\n      </tr>\n      '\
 731             + '<tr>\n        <td>User A</td>\n        <td>User B</td>\n        '\
 732             + '<td><button type="submit" class="btn btn-danger" name="id" value="1">Revoke</button></td>\n      </tr>\n      '\
 733             + '<tr>\n        <td>User C</td>\n        <td>User B</td>\n        '\
 734             + '<td><button type="submit" class="btn btn-danger" name="id" value="2">Revoke</button></td>\n      '\
 735             + '</tr>\n    </table>\n'
 736         self.assertIn(str.encode(testtext), result.data)
 737         testtext= 'proxy granted to: User A\n'
 738         self.assertIn(str.encode(testtext), result.data)
 739         testtext= 'holds proxy of:'
 740         self.assertNotIn(str.encode(testtext), result.data)
 741
 742         response = self.revokeProxy(user, 3)
 743         self.assertEqual(response.status_code, 302)
 744         result = self.app.get('proxy', environ_base={'USER_ROLES': user}, follow_redirects=True)
 745         testtext= '<table>\n      '\
 746             + '<thead>\n        '\
 747             + '<th>Voter</th>\n        <th>Proxy</th>\n        <th></th>\n      </thead>\n      '\
 748             + '<tr>\n        <td>User A</td>\n        <td>User B</td>\n        '\
 749             + '<td><button type="submit" class="btn btn-danger" name="id" value="1">Revoke</button></td>\n      </tr>\n      '\
 750             + '<tr>\n        <td>User C</td>\n        <td>User B</td>\n        '\
 751             + '<td><button type="submit" class="btn btn-danger" name="id" value="2">Revoke</button></td>\n      '\
 752             + '</tr>\n    </table>\n'
 753         self.assertIn(str.encode(testtext), result.data)
 754         testtext= 'proxy granted to:'
 755         self.assertNotIn(str.encode(testtext), result.data)
 756         testtext= 'holds proxy of:'
 757         self.assertNotIn(str.encode(testtext), result.data)
 758
 759         result = self.app.post('proxy/revokeall', environ_base={'USER_ROLES': user}, follow_redirects=True)
 760         self.assertEqual(response.status_code, 302)
 761         result = self.app.get('proxy', environ_base={'USER_ROLES': user}, follow_redirects=True)
 762         testtext= '<table>\n      '\
 763             + '<thead>\n        '\
 764             + '<th>Voter</th>\n        <th>Proxy</th>\n        <th></th>\n      </thead>\n    '\
 765             + '</table>\n'
 766         self.assertIn(str.encode(testtext), result.data)
 767
 768 class ProxyVoteTests(BasicTest):
 769
 770     def setUp(self):
 771         self.init_test()
 772         global user
 773         user='testuser/vote:* proxyadmin:*'
 774         self.db_sampledata()
 775
 776     def tearDown(self):
 777         pass
 778
 779     def test_proxy_vote(self):
 780         voter='testuser'
 781         proxy='User B'
 782         proxyid=2
 783         proxyuser='User B/vote:*'
 784
 785         response = self.addProxy(user, proxy, voter)
 786         self.assertEqual(response.status_code, 302)
 787
 788         motion='g1.20200402.004'
 789         response = self.createVote(user, motion, 'yes', proxyid)
 790         self.assertEqual(response.status_code, 302)
 791
 792         # testuser view
 793         result = self.app.get('/motion/' + motion, environ_base={'USER_ROLES': user}, follow_redirects=True)
 794         # own vote without change
 795         testtext= '<form action="/motion/g1.20200402.004/vote/4" method="POST">\n'\
 796             + '<button type="submit" class="btn btn-primary" name="vote" value="yes" id="vote-yes">yes</button>\n'\
 797             + '<button type="submit" class="btn btn-primary" name="vote" value="no" id="vote-no">no</button>\n'\
 798             + '<button type="submit" class="btn btn-primary" name="vote" value="abstain" id="vote-abstain">abstain</button>\n</form>'
 799         self.assertIn(str.encode(testtext), result.data)
 800         # proxy vote with change
 801         testtext= '<form action="/motion/g1.20200402.004/vote/2" method="POST">\n'\
 802             + '<button type="submit" class="btn btn-success" name="vote" value="yes" id="vote-yes">yes</button>\n'\
 803             + '<button type="submit" class="btn btn-primary" name="vote" value="no" id="vote-no">no</button>\n'\
 804             + '<button type="submit" class="btn btn-primary" name="vote" value="abstain" id="vote-abstain">abstain</button>\n</form>\n'
 805         self.assertIn(str.encode(testtext), result.data)
 806
 807         # User B view
 808         result = self.app.get('/motion/' + motion, environ_base={'USER_ROLES': proxyuser}, follow_redirects=True)
 809         # own vote without change
 810         testtext= '<h3>My vote</h3>\nGiven by testuser\n'\
 811             + '<form action="/motion/g1.20200402.004/vote/2" method="POST">\n'\
 812             + '<button type="submit" class="btn btn-success" name="vote" value="yes" id="vote-yes">yes</button>\n'\
 813             + '<button type="submit" class="btn btn-primary" name="vote" value="no" id="vote-no">no</button>\n'\
 814             + '<button type="submit" class="btn btn-primary" name="vote" value="abstain" id="vote-abstain">abstain</button>\n</form>'
 815         self.assertIn(str.encode(testtext), result.data)
 816
 817         # change vote
 818         response = self.createVote(user, motion, 'no', proxyid)
 819         self.assertEqual(response.status_code, 302)
 820
 821         result = self.app.get('/motion/' + motion, environ_base={'USER_ROLES': user}, follow_redirects=True)
 822         testtext= '<form action="/motion/g1.20200402.004/vote/2" method="POST">\n'\
 823             + '<button type="submit" class="btn btn-primary" name="vote" value="yes" id="vote-yes">yes</button>\n'\
 824             + '<button type="submit" class="btn btn-success" name="vote" value="no" id="vote-no">no</button>\n'\
 825             + '<button type="submit" class="btn btn-primary" name="vote" value="abstain" id="vote-abstain">abstain</button>\n</form>\n'
 826         self.assertIn(str.encode(testtext), result.data)
 827
 828     def test_proxy_vote_no_proxy(self):
 829         voter='testuser'
 830         proxy='User B'
 831         # wrong proxy id
 832         proxyid=3
 833
 834         response = self.addProxy(user, proxy, voter)
 835         self.assertEqual(response.status_code, 302)
 836
 837         motion='g1.20200402.004'
 838         response = self.createVote(user, motion, 'yes', proxyid)
 839         self.assertEqual(response.status_code, 400)
 840         self.assertIn(str.encode('Error, proxy not found'), response.data)
 841
 842         # non existing id
 843         proxyid=10000
 844
 845         motion='g1.20200402.004'
 846         response = self.createVote(user, motion, 'yes', proxyid)
 847         self.assertEqual(response.status_code, 400)
 848         self.assertIn(str.encode('Error, proxy not found'), response.data)
 849
 850     def test_proxy_vote_no_voter(self):
 851         voter='User A'
 852         proxy='User B'
 853         proxyid=2
 854
 855         response = self.addProxy(user, proxy, voter)
 856         self.assertEqual(response.status_code, 302)
 857
 858         user1='testuser1/'
 859         motion='g1.20200402.004'
 860         response = self.createVote(user1, motion, 'yes', proxyid)
 861         self.assertEqual(response.status_code, 403)
 862         self.assertIn(str.encode('Forbidden'), response.data)
 863
 864
 865
 866 if __name__ == "__main__":
 867     unittest.main()