test_person_permissions.py 17.1 KB
Newer Older
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
# coding: utf8
"""
Test permissions
"""
from __future__ import print_function
from __future__ import absolute_import
from __future__ import division
from __future__ import unicode_literals
from django.test import TestCase
from backend import const
from backend.test_common import *

class WhenView(NMTestUtilsWhen):
    def setUp(self, fixture):
        super(WhenView, self).setUp(fixture)
        self.url = reverse("person", kwargs={ "key": self.args["person"].lookup_key })

class ThenPerms(ThenSuccess):
    def __init__(self, perms):
        self.perms_expected = frozenset(perms.split() if perms else ())
    def __call__(self, fixture, response, when, test_client):
        super(ThenPerms, self).__call__(fixture, response, when, test_client)
        perms = response.context["vperms"].perms
        if perms != self.perms_expected:
            fixture.fail("{} got permissions ({}) instead of ({}) when {}".format(
                when.user, ", ".join(sorted(perms)), ", ".join(sorted(self.perms_expected)), when))

class ThenCanAdv(ThenSuccess):
    def __init__(self, adv):
        self.adv_expected = frozenset(adv.split() if adv else ())
    def __call__(self, fixture, response, when, test_client):
        super(ThenCanAdv, self).__call__(fixture, response, when, test_client)
        adv = frozenset(response.context["vperms"].advocate_targets)
        if adv != self.adv_expected:
            fixture.fail("{} can advocate for ({}) instead of ({}) when {}".format(
                when.user, ", ".join(sorted(adv)), ", ".join(sorted(self.adv_expected)), when))

class visit_base(object):
    def __init__(self, fixture, person, other_perms="", other_advs=""):
        self.fixture = fixture
        self.visitors_perms_seen = set()
        self.visitors_advs_seen = set()
        self.other_perms = other_perms
        self.other_advs = other_advs
        self.person = fixture.users[person]

    def __enter__(self):
        self.fixture.visit = self
        return self

    def _check_other_perms(self):
        "Test all other users not tested in the previous loop"
        if None not in self.visitors_perms_seen:
            self.fixture.assertVisit(WhenView(person=self.person), ThenPerms(self.other_perms))
        for u in self.fixture.users.viewkeys() - self.visitors_perms_seen:
            self.fixture.assertVisit(WhenView(person=self.person, user=self.fixture.users[u]), ThenPerms(self.other_perms))

    def _check_other_advs(self):
        "Test all other users not tested in the previous loop"
        if None not in self.visitors_advs_seen:
            self.fixture.assertVisit(WhenView(person=self.person), ThenCanAdv(self.other_advs))
        for u in self.fixture.users.viewkeys() - self.visitors_advs_seen:
            self.fixture.assertVisit(WhenView(person=self.person, user=self.fixture.users[u]), ThenCanAdv(self.other_advs))

class visit(visit_base):
    def __exit__(self, type, value, traceback):
        if type is not None: return
        self._check_other_perms()
        self._check_other_advs()
        self.fixture.visit = None

class visit_perms(visit_base):
    def __exit__(self, type, value, traceback):
        if type is not None: return
        self._check_other_perms()
        self.fixture.visit = None

class visit_advs(visit_base):
    def __exit__(self, type, value, traceback):
        if type is not None: return
        self._check_other_advs()
        self.fixture.visit = None

class PersonTestMixin(NMBasicFixtureMixin, NMTestUtilsMixin):
    def assertPerms(self, who, perms=""):
        # Go through all combinations of visitors and expected results
        for u in who.split():
            if u is None:
                self.assertVisit(WhenView(person=self.visit.person), ThenPerms(perms))
            else:
                self.assertVisit(WhenView(person=self.visit.person, user=self.users[u]), ThenPerms(perms))
            self.visit.visitors_perms_seen.add(u)

    def assertAdvs(self, who, adv):
        # Go through all combinations of visitors and expected results
        for u in who.split():
            if u is None:
                self.assertVisit(WhenView(person=self.visit.person), ThenCanAdv(adv))
            else:
                self.assertVisit(WhenView(person=self.visit.person, user=self.users[u]), ThenCanAdv(adv))
            self.visit.visitors_advs_seen.add(u)


Enrico Zini's avatar
Enrico Zini committed
104
class ProcTestMixin(PersonTestMixin):
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
    applying_as = None
    applying_for = None
    advocate_status = const.STATUS_DD_NU

    def setUp(self):
        super(ProcTestMixin, self).setUp()
        self.app = self.make_user("app", self.applying_as, alioth=True)
        self.adv = self.make_user("adv", self.advocate_status)
        self.am = self.make_user("am", const.STATUS_DD_NU)
        self.am_am = bmodels.AM.objects.create(person=self.am)
        self.proc = self.make_process(self.app, self.applying_for, const.PROGRESS_APP_RCVD)

    def assertAdvsInitial(self): self.fail("Not implemented")
    def assertAdvsAdv(self): self.fail("Not implemented")
    def assertAdvsAdvAM(self): self.fail("Not implemented")
    def assertAdvsFDDAM(self): self.fail("Not implemented")
    def assertAdvsDone(self): self.fail("Not implemented")

    def test_advs(self):
        self.proc.advocates.clear()
        self.proc.manager = None
        self.proc.save()

        # States without advocates and AMs
        for p in (const.PROGRESS_APP_NEW, const.PROGRESS_APP_RCVD, const.PROGRESS_APP_HOLD, const.PROGRESS_ADV_RCVD, const.PROGRESS_POLL_SENT):
            self.proc.progress = p
            self.proc.save()
            with visit_advs(self, "app"):
                self.assertAdvsInitial()

        # States with advocates and no AMs
        self.proc.advocates.add(self.adv)
        for p in (const.PROGRESS_APP_OK,):
            self.proc.progress = p
            self.proc.save()
            with visit_advs(self, "app"):
                self.assertAdvsAdv()

        # States with advocates and AMs
        self.proc.manager = self.am_am
        for p in (const.PROGRESS_AM_RCVD, const.PROGRESS_AM, const.PROGRESS_AM_HOLD):
            self.proc.progress = p
            self.proc.save()
            with visit_advs(self, "app"):
                self.assertAdvsAdvAM()

        # States after the AM
        for p in (const.PROGRESS_AM_OK, const.PROGRESS_FD_HOLD, const.PROGRESS_FD_OK, const.PROGRESS_DAM_HOLD, const.PROGRESS_DAM_OK):
            self.proc.progress = p
            self.proc.save()

            with visit_advs(self, "app"):
157
                self.assertAdvsFDDAM()
158
159

        # Final states
160
        self.app.status = self.applying_for
161
        self.app.save(audit_skip=True)
162
163
164
165
166
167
        for p in (const.PROGRESS_DONE, const.PROGRESS_CANCELLED):
            self.proc.progress = p
            self.proc.is_active = False
            self.proc.save()

            with visit_advs(self, "app"):
168
                self.assertAdvsDone()
169

Enrico Zini's avatar
Enrico Zini committed
170
171
    # Standard behaviour
    def assertPermsInitial(self):
172
        self.assertPerms("fd dam app", "update_keycheck edit_bio edit_ldap view_person_audit_log")
Enrico Zini's avatar
Enrico Zini committed
173
        self.assertPerms("adv dd_nu dd_u am", "view_person_audit_log")
Enrico Zini's avatar
Enrico Zini committed
174
    def assertPermsAdv(self):
175
        self.assertPerms("fd dam adv app", "update_keycheck edit_bio edit_ldap view_person_audit_log")
Enrico Zini's avatar
Enrico Zini committed
176
        self.assertPerms("dd_nu dd_u am", "view_person_audit_log")
Enrico Zini's avatar
Enrico Zini committed
177
    def assertPermsAdvAM(self):
178
        self.assertPerms("fd dam adv am app", "update_keycheck edit_bio edit_ldap view_person_audit_log")
Enrico Zini's avatar
Enrico Zini committed
179
        self.assertPerms("dd_nu dd_u", "view_person_audit_log")
Enrico Zini's avatar
Enrico Zini committed
180
    def assertPermsFDDAM(self):
181
182
        self.assertPerms("fd dam", "update_keycheck edit_bio edit_ldap view_person_audit_log")
        self.assertPerms("app", "update_keycheck edit_bio view_person_audit_log")
Enrico Zini's avatar
Enrico Zini committed
183
        self.assertPerms("adv dd_nu dd_u am", "view_person_audit_log")
Enrico Zini's avatar
Enrico Zini committed
184
    def assertPermsDone(self):
185
        self.assertPerms("fd dam app", "update_keycheck edit_bio view_person_audit_log")
Enrico Zini's avatar
Enrico Zini committed
186
        self.assertPerms("adv dd_nu dd_u am", "view_person_audit_log")
Enrico Zini's avatar
Enrico Zini committed
187

188
189
190
191
192
193
194
195
196
197
    def test_perms(self):
        self.proc.advocates.clear()
        self.proc.manager = None
        self.proc.save()

        # States without advocates and AMs
        for p in (const.PROGRESS_APP_NEW, const.PROGRESS_APP_RCVD, const.PROGRESS_APP_HOLD, const.PROGRESS_ADV_RCVD, const.PROGRESS_POLL_SENT):
            self.proc.progress = p
            self.proc.save()
            with visit_perms(self, "app"):
Enrico Zini's avatar
Enrico Zini committed
198
                self.assertPermsInitial()
199
200
201
202
203
204
205

        # States with advocates and no AMs
        self.proc.advocates.add(self.adv)
        for p in (const.PROGRESS_APP_OK,):
            self.proc.progress = p
            self.proc.save()
            with visit_perms(self, "app"):
Enrico Zini's avatar
Enrico Zini committed
206
                self.assertPermsAdv()
207
208
209
210
211
212
213

        # States with advocates and AMs
        self.proc.manager = self.am_am
        for p in (const.PROGRESS_AM_RCVD, const.PROGRESS_AM, const.PROGRESS_AM_HOLD):
            self.proc.progress = p
            self.proc.save()
            with visit_perms(self, "app"):
Enrico Zini's avatar
Enrico Zini committed
214
                self.assertPermsAdvAM()
215
216
217
218
219
220
221

        # States after the AM
        for p in (const.PROGRESS_AM_OK, const.PROGRESS_FD_HOLD, const.PROGRESS_FD_OK, const.PROGRESS_DAM_HOLD, const.PROGRESS_DAM_OK):
            self.proc.progress = p
            self.proc.save()

            with visit_perms(self, "app"):
Enrico Zini's avatar
Enrico Zini committed
222
                self.assertPermsFDDAM()
223
224

        # Final states
225
        self.app.status = self.applying_for
226
        self.app.save(audit_skip=True)
227
228
229
230
231
232
        for p in (const.PROGRESS_DONE, const.PROGRESS_CANCELLED):
            self.proc.progress = p
            self.proc.is_active = False
            self.proc.save()

            with visit_perms(self, "app"):
Enrico Zini's avatar
Enrico Zini committed
233
                self.assertPermsDone()
234
235
236
237


class ProcDcDdnuTestCase(ProcTestMixin, TestCase):
    """
Enrico Zini's avatar
Enrico Zini committed
238
    Test all visit combinations for an applicant from dc to dd_nu, with dd_nu advocate
239
    """
Enrico Zini's avatar
Enrico Zini committed
240
    applying_as = const.STATUS_DC
241
242
243
244
    applying_for = const.STATUS_DD_NU
    advocate_status = const.STATUS_DD_NU

    def assertAdvsInitial(self):
Enrico Zini's avatar
Enrico Zini committed
245
246
        self.assertAdvs("fd dam adv am dd_nu dd_u", "dc_ga dm dd_u dd_nu")
        self.assertAdvs("dm dm_ga", "dc_ga")
247
    def assertAdvsAdv(self):
Enrico Zini's avatar
Enrico Zini committed
248
249
250
        self.assertAdvs("fd dam am dd_nu dd_u", "dc_ga dm dd_u dd_nu")
        self.assertAdvs("dm dm_ga", "dc_ga")
        self.assertAdvs("adv", "dc_ga dm")
251
    def assertAdvsAdvAM(self):
Enrico Zini's avatar
Enrico Zini committed
252
253
254
        self.assertAdvs("fd dam dd_nu dd_u", "dc_ga dm dd_u dd_nu")
        self.assertAdvs("dm dm_ga", "dc_ga")
        self.assertAdvs("adv am", "dc_ga dm")
255
    def assertAdvsFDDAM(self):
Enrico Zini's avatar
Enrico Zini committed
256
257
        self.assertAdvs("fd dam adv am dd_nu dd_u", "dc_ga dm")
        self.assertAdvs("dm dm_ga", "dc_ga")
258
    def assertAdvsDone(self):
Enrico Zini's avatar
Enrico Zini committed
259
        pass
260
261
262
263
264

class ProcDcgaDdnuTestCase(ProcTestMixin, TestCase):
    """
    Test all visit combinations for an applicant from dc to dc_ga, with a dm advocate
    """
Enrico Zini's avatar
Enrico Zini committed
265
    applying_as = const.STATUS_DC_GA
266
267
268
269
    applying_for = const.STATUS_DD_NU
    advocate_status = const.STATUS_DD_NU

    def assertAdvsInitial(self):
Enrico Zini's avatar
Enrico Zini committed
270
        self.assertAdvs("fd dam adv am dd_nu dd_u", "dm_ga dd_u dd_nu")
271
    def assertAdvsAdv(self):
Enrico Zini's avatar
Enrico Zini committed
272
273
        self.assertAdvs("fd dam am dd_nu dd_u", "dm_ga dd_u dd_nu")
        self.assertAdvs("adv", "dm_ga")
274
    def assertAdvsAdvAM(self):
Enrico Zini's avatar
Enrico Zini committed
275
276
        self.assertAdvs("fd dam dd_nu dd_u", "dm_ga dd_u dd_nu")
        self.assertAdvs("adv am", "dm_ga")
277
    def assertAdvsFDDAM(self):
Enrico Zini's avatar
Enrico Zini committed
278
        self.assertAdvs("fd dam adv am dd_nu dd_u", "dm_ga")
279
    def assertAdvsDone(self):
Enrico Zini's avatar
Enrico Zini committed
280
        pass
281

Enrico Zini's avatar
Enrico Zini committed
282
    def assertPermsInitial(self):
283
        self.assertPerms("fd dam app", "update_keycheck edit_bio view_person_audit_log")
Enrico Zini's avatar
Enrico Zini committed
284
        self.assertPerms("adv dd_nu dd_u am", "view_person_audit_log")
Enrico Zini's avatar
Enrico Zini committed
285
    def assertPermsAdv(self):
286
        self.assertPerms("fd dam adv app", "update_keycheck edit_bio view_person_audit_log")
Enrico Zini's avatar
Enrico Zini committed
287
        self.assertPerms("dd_nu dd_u am", "view_person_audit_log")
Enrico Zini's avatar
Enrico Zini committed
288
    def assertPermsAdvAM(self):
289
        self.assertPerms("fd dam adv am app", "update_keycheck edit_bio view_person_audit_log")
Enrico Zini's avatar
Enrico Zini committed
290
        self.assertPerms("dd_nu dd_u", "view_person_audit_log")
Enrico Zini's avatar
Enrico Zini committed
291
    def assertPermsFDDAM(self):
292
293
        self.assertPerms("fd dam", "update_keycheck edit_bio view_person_audit_log")
        self.assertPerms("app", "update_keycheck edit_bio view_person_audit_log")
Enrico Zini's avatar
Enrico Zini committed
294
        self.assertPerms("adv dd_nu dd_u am", "view_person_audit_log")
Enrico Zini's avatar
Enrico Zini committed
295

296
297
298
299
class ProcDcDduTestCase(ProcTestMixin, TestCase):
    """
    Test all visit combinations for an applicant from dc to dc_ga, with a dm advocate
    """
Enrico Zini's avatar
Enrico Zini committed
300
    applying_as = const.STATUS_DC
301
302
303
304
    applying_for = const.STATUS_DD_U
    advocate_status = const.STATUS_DD_U

    def assertAdvsInitial(self):
Enrico Zini's avatar
Enrico Zini committed
305
306
        self.assertAdvs("fd dam adv am dd_nu dd_u", "dc_ga dm dd_u dd_nu")
        self.assertAdvs("dm dm_ga", "dc_ga")
307
    def assertAdvsAdv(self):
Enrico Zini's avatar
Enrico Zini committed
308
309
310
        self.assertAdvs("fd dam am dd_nu dd_u", "dc_ga dm dd_u dd_nu")
        self.assertAdvs("dm dm_ga", "dc_ga")
        self.assertAdvs("adv", "dc_ga dm")
311
    def assertAdvsAdvAM(self):
Enrico Zini's avatar
Enrico Zini committed
312
313
314
        self.assertAdvs("fd dam dd_nu dd_u", "dc_ga dm dd_u dd_nu")
        self.assertAdvs("dm dm_ga", "dc_ga")
        self.assertAdvs("adv am", "dc_ga dm")
315
    def assertAdvsFDDAM(self):
Enrico Zini's avatar
Enrico Zini committed
316
317
        self.assertAdvs("fd dam adv am dd_nu dd_u", "dc_ga dm")
        self.assertAdvs("dm dm_ga", "dc_ga")
318
    def assertAdvsDone(self):
Enrico Zini's avatar
Enrico Zini committed
319
        pass
320
321
322
323
324

class ProcDcgaDduTestCase(ProcTestMixin, TestCase):
    """
    Test all visit combinations for an applicant from dc to dc_ga, with a dm advocate
    """
Enrico Zini's avatar
Enrico Zini committed
325
    applying_as = const.STATUS_DC_GA
326
327
328
329
    applying_for = const.STATUS_DD_U
    advocate_status = const.STATUS_DD_U

    def assertAdvsInitial(self):
Enrico Zini's avatar
Enrico Zini committed
330
        self.assertAdvs("fd dam adv am dd_nu dd_u", "dm_ga dd_u dd_nu")
331
    def assertAdvsAdv(self):
Enrico Zini's avatar
Enrico Zini committed
332
333
        self.assertAdvs("fd dam am dd_nu dd_u", "dm_ga dd_u dd_nu")
        self.assertAdvs("adv", "dm_ga")
334
    def assertAdvsAdvAM(self):
Enrico Zini's avatar
Enrico Zini committed
335
336
        self.assertAdvs("fd dam dd_nu dd_u", "dm_ga dd_u dd_nu")
        self.assertAdvs("adv am", "dm_ga")
337
    def assertAdvsFDDAM(self):
Enrico Zini's avatar
Enrico Zini committed
338
        self.assertAdvs("fd dam adv am dd_nu dd_u", "dm_ga")
339
    def assertAdvsDone(self):
Enrico Zini's avatar
Enrico Zini committed
340
        pass
341

Enrico Zini's avatar
Enrico Zini committed
342
    def assertPermsInitial(self):
343
        self.assertPerms("fd dam app", "update_keycheck edit_bio view_person_audit_log")
Enrico Zini's avatar
Enrico Zini committed
344
        self.assertPerms("adv dd_nu dd_u am", "view_person_audit_log")
Enrico Zini's avatar
Enrico Zini committed
345
    def assertPermsAdv(self):
346
        self.assertPerms("fd dam adv app", "update_keycheck edit_bio view_person_audit_log")
Enrico Zini's avatar
Enrico Zini committed
347
        self.assertPerms("dd_nu dd_u am", "view_person_audit_log")
Enrico Zini's avatar
Enrico Zini committed
348
    def assertPermsAdvAM(self):
349
        self.assertPerms("fd dam adv am app", "update_keycheck edit_bio view_person_audit_log")
Enrico Zini's avatar
Enrico Zini committed
350
        self.assertPerms("dd_nu dd_u", "view_person_audit_log")
Enrico Zini's avatar
Enrico Zini committed
351
    def assertPermsFDDAM(self):
352
353
        self.assertPerms("fd dam", "update_keycheck edit_bio view_person_audit_log")
        self.assertPerms("app", "update_keycheck edit_bio view_person_audit_log")
Enrico Zini's avatar
Enrico Zini committed
354
        self.assertPerms("adv dd_nu dd_u am", "view_person_audit_log")
Enrico Zini's avatar
Enrico Zini committed
355

356
357
358
359
360
361
362
363
364
class ProcDmDduTestCase(ProcTestMixin, TestCase):
    """
    Test all visit combinations for an applicant from dc to dc_ga, with a dm advocate
    """
    applying_as = const.STATUS_DM
    applying_for = const.STATUS_DD_U
    advocate_status = const.STATUS_DD_U

    def assertAdvsInitial(self):
Enrico Zini's avatar
Enrico Zini committed
365
366
        self.assertAdvs("fd dam adv am dd_nu dd_u", "dm_ga dd_u dd_nu")
        self.assertAdvs("app dm dm_ga", "dm_ga")
367
    def assertAdvsAdv(self):
Enrico Zini's avatar
Enrico Zini committed
368
369
        self.assertAdvs("fd dam am dd_nu dd_u", "dm_ga dd_u dd_nu")
        self.assertAdvs("adv app dm dm_ga", "dm_ga")
370
    def assertAdvsAdvAM(self):
Enrico Zini's avatar
Enrico Zini committed
371
372
        self.assertAdvs("fd dam dd_nu dd_u", "dm_ga dd_u dd_nu")
        self.assertAdvs("adv am app dm dm_ga", "dm_ga")
373
    def assertAdvsFDDAM(self):
Enrico Zini's avatar
Enrico Zini committed
374
        self.assertAdvs("fd dam dd_nu dd_u adv am app dm dm_ga", "dm_ga")
375
    def assertAdvsDone(self):
Enrico Zini's avatar
Enrico Zini committed
376
        pass
377
378
379

class ProcDmgaDduTestCase(ProcTestMixin, TestCase):
    """
Enrico Zini's avatar
Enrico Zini committed
380
    Test all visit combinations for an applicant from dm_ga to dd_u, with a dd_u advocate
381
382
383
384
385
386
    """
    applying_as = const.STATUS_DM_GA
    applying_for = const.STATUS_DD_U
    advocate_status = const.STATUS_DD_U

    def assertAdvsInitial(self):
Enrico Zini's avatar
Enrico Zini committed
387
        self.assertAdvs("fd dam adv am dd_nu dd_u", "dd_u dd_nu")
388
    def assertAdvsAdv(self):
Enrico Zini's avatar
Enrico Zini committed
389
        self.assertAdvs("fd dam am dd_nu dd_u", "dd_u dd_nu")
390
    def assertAdvsAdvAM(self):
Enrico Zini's avatar
Enrico Zini committed
391
        self.assertAdvs("fd dam dd_nu dd_u", "dd_u dd_nu")
392
    def assertAdvsFDDAM(self):
Enrico Zini's avatar
Enrico Zini committed
393
        pass
394
    def assertAdvsDone(self):
Enrico Zini's avatar
Enrico Zini committed
395
        pass
396

Enrico Zini's avatar
Enrico Zini committed
397
    def assertPermsInitial(self):
398
        self.assertPerms("fd dam app", "update_keycheck edit_bio view_person_audit_log")
Enrico Zini's avatar
Enrico Zini committed
399
        self.assertPerms("adv dd_nu dd_u am", "view_person_audit_log")
Enrico Zini's avatar
Enrico Zini committed
400
    def assertPermsAdv(self):
401
        self.assertPerms("fd dam adv app", "update_keycheck edit_bio view_person_audit_log")
Enrico Zini's avatar
Enrico Zini committed
402
        self.assertPerms("dd_nu dd_u am", "view_person_audit_log")
Enrico Zini's avatar
Enrico Zini committed
403
    def assertPermsAdvAM(self):
404
        self.assertPerms("fd dam adv am app", "update_keycheck edit_bio view_person_audit_log")
Enrico Zini's avatar
Enrico Zini committed
405
        self.assertPerms("dd_nu dd_u", "view_person_audit_log")
Enrico Zini's avatar
Enrico Zini committed
406
    def assertPermsFDDAM(self):
407
408
        self.assertPerms("fd dam", "update_keycheck edit_bio view_person_audit_log")
        self.assertPerms("app", "update_keycheck edit_bio view_person_audit_log")
Enrico Zini's avatar
Enrico Zini committed
409
        self.assertPerms("adv dd_nu dd_u am", "view_person_audit_log")
Enrico Zini's avatar
Enrico Zini committed
410
    def assertPermsDone(self):
411
        self.assertPerms("fd dam app", "update_keycheck edit_bio view_person_audit_log")
Enrico Zini's avatar
Enrico Zini committed
412
        self.assertPerms("adv dd_nu dd_u am", "view_person_audit_log")