test_person_permissions.py

# 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)


class ProcTestMixin(PersonTestMixin):
    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"):
                self.assertAdvsFDDAM()

        # Final states
        self.app.status = self.applying_for
        self.app.save(audit_skip=True)
        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"):
                self.assertAdvsDone()

    # Standard behaviour
    def assertPermsInitial(self):
        self.assertPerms("fd dam app", "update_keycheck edit_bio edit_ldap view_person_audit_log")
        self.assertPerms("adv dd_nu dd_u am", "view_person_audit_log")
    def assertPermsAdv(self):
        self.assertPerms("fd dam adv app", "update_keycheck edit_bio edit_ldap view_person_audit_log")
        self.assertPerms("dd_nu dd_u am", "view_person_audit_log")
    def assertPermsAdvAM(self):
        self.assertPerms("fd dam adv am app", "update_keycheck edit_bio edit_ldap view_person_audit_log")
        self.assertPerms("dd_nu dd_u", "view_person_audit_log")
    def assertPermsFDDAM(self):
        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")
        self.assertPerms("adv dd_nu dd_u am", "view_person_audit_log")
    def assertPermsDone(self):
        self.assertPerms("fd dam app", "update_keycheck edit_bio view_person_audit_log")
        self.assertPerms("adv dd_nu dd_u am", "view_person_audit_log")

    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"):
                self.assertPermsInitial()

        # 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"):
                self.assertPermsAdv()

        # 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"):
                self.assertPermsAdvAM()

        # 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"):
                self.assertPermsFDDAM()

        # Final states
        self.app.status = self.applying_for
        self.app.save(audit_skip=True)
        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"):
                self.assertPermsDone()


class ProcDcDdnuTestCase(ProcTestMixin, TestCase):
    """
    Test all visit combinations for an applicant from dc to dd_nu, with dd_nu advocate
    """
    applying_as = const.STATUS_DC
    applying_for = const.STATUS_DD_NU
    advocate_status = const.STATUS_DD_NU

    def assertAdvsInitial(self):
        self.assertAdvs("fd dam adv am dd_nu dd_u", "dc_ga dm dd_u dd_nu")
        self.assertAdvs("dm dm_ga", "dc_ga")
    def assertAdvsAdv(self):
        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")
    def assertAdvsAdvAM(self):
        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")
    def assertAdvsFDDAM(self):
        self.assertAdvs("fd dam adv am dd_nu dd_u", "dc_ga dm")
        self.assertAdvs("dm dm_ga", "dc_ga")
    def assertAdvsDone(self):
        pass

class ProcDcgaDdnuTestCase(ProcTestMixin, TestCase):
    """
    Test all visit combinations for an applicant from dc to dc_ga, with a dm advocate
    """
    applying_as = const.STATUS_DC_GA
    applying_for = const.STATUS_DD_NU
    advocate_status = const.STATUS_DD_NU

    def assertAdvsInitial(self):
        self.assertAdvs("fd dam adv am dd_nu dd_u", "dm_ga dd_u dd_nu")
    def assertAdvsAdv(self):
        self.assertAdvs("fd dam am dd_nu dd_u", "dm_ga dd_u dd_nu")
        self.assertAdvs("adv", "dm_ga")
    def assertAdvsAdvAM(self):
        self.assertAdvs("fd dam dd_nu dd_u", "dm_ga dd_u dd_nu")
        self.assertAdvs("adv am", "dm_ga")
    def assertAdvsFDDAM(self):
        self.assertAdvs("fd dam adv am dd_nu dd_u", "dm_ga")
    def assertAdvsDone(self):
        pass

    def assertPermsInitial(self):
        self.assertPerms("fd dam app", "update_keycheck edit_bio view_person_audit_log")
        self.assertPerms("adv dd_nu dd_u am", "view_person_audit_log")
    def assertPermsAdv(self):
        self.assertPerms("fd dam adv app", "update_keycheck edit_bio view_person_audit_log")
        self.assertPerms("dd_nu dd_u am", "view_person_audit_log")
    def assertPermsAdvAM(self):
        self.assertPerms("fd dam adv am app", "update_keycheck edit_bio view_person_audit_log")
        self.assertPerms("dd_nu dd_u", "view_person_audit_log")
    def assertPermsFDDAM(self):
        self.assertPerms("fd dam", "update_keycheck edit_bio view_person_audit_log")
        self.assertPerms("app", "update_keycheck edit_bio view_person_audit_log")
        self.assertPerms("adv dd_nu dd_u am", "view_person_audit_log")

class ProcDcDduTestCase(ProcTestMixin, TestCase):
    """
    Test all visit combinations for an applicant from dc to dc_ga, with a dm advocate
    """
    applying_as = const.STATUS_DC
    applying_for = const.STATUS_DD_U
    advocate_status = const.STATUS_DD_U

    def assertAdvsInitial(self):
        self.assertAdvs("fd dam adv am dd_nu dd_u", "dc_ga dm dd_u dd_nu")
        self.assertAdvs("dm dm_ga", "dc_ga")
    def assertAdvsAdv(self):
        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")
    def assertAdvsAdvAM(self):
        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")
    def assertAdvsFDDAM(self):
        self.assertAdvs("fd dam adv am dd_nu dd_u", "dc_ga dm")
        self.assertAdvs("dm dm_ga", "dc_ga")
    def assertAdvsDone(self):
        pass

class ProcDcgaDduTestCase(ProcTestMixin, TestCase):
    """
    Test all visit combinations for an applicant from dc to dc_ga, with a dm advocate
    """
    applying_as = const.STATUS_DC_GA
    applying_for = const.STATUS_DD_U
    advocate_status = const.STATUS_DD_U

    def assertAdvsInitial(self):
        self.assertAdvs("fd dam adv am dd_nu dd_u", "dm_ga dd_u dd_nu")
    def assertAdvsAdv(self):
        self.assertAdvs("fd dam am dd_nu dd_u", "dm_ga dd_u dd_nu")
        self.assertAdvs("adv", "dm_ga")
    def assertAdvsAdvAM(self):
        self.assertAdvs("fd dam dd_nu dd_u", "dm_ga dd_u dd_nu")
        self.assertAdvs("adv am", "dm_ga")
    def assertAdvsFDDAM(self):
        self.assertAdvs("fd dam adv am dd_nu dd_u", "dm_ga")
    def assertAdvsDone(self):
        pass

    def assertPermsInitial(self):
        self.assertPerms("fd dam app", "update_keycheck edit_bio view_person_audit_log")
        self.assertPerms("adv dd_nu dd_u am", "view_person_audit_log")
    def assertPermsAdv(self):
        self.assertPerms("fd dam adv app", "update_keycheck edit_bio view_person_audit_log")
        self.assertPerms("dd_nu dd_u am", "view_person_audit_log")
    def assertPermsAdvAM(self):
        self.assertPerms("fd dam adv am app", "update_keycheck edit_bio view_person_audit_log")
        self.assertPerms("dd_nu dd_u", "view_person_audit_log")
    def assertPermsFDDAM(self):
        self.assertPerms("fd dam", "update_keycheck edit_bio view_person_audit_log")
        self.assertPerms("app", "update_keycheck edit_bio view_person_audit_log")
        self.assertPerms("adv dd_nu dd_u am", "view_person_audit_log")

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):
        self.assertAdvs("fd dam adv am dd_nu dd_u", "dm_ga dd_u dd_nu")
        self.assertAdvs("app dm dm_ga", "dm_ga")
    def assertAdvsAdv(self):
        self.assertAdvs("fd dam am dd_nu dd_u", "dm_ga dd_u dd_nu")
        self.assertAdvs("adv app dm dm_ga", "dm_ga")
    def assertAdvsAdvAM(self):
        self.assertAdvs("fd dam dd_nu dd_u", "dm_ga dd_u dd_nu")
        self.assertAdvs("adv am app dm dm_ga", "dm_ga")
    def assertAdvsFDDAM(self):
        self.assertAdvs("fd dam dd_nu dd_u adv am app dm dm_ga", "dm_ga")
    def assertAdvsDone(self):
        pass

class ProcDmgaDduTestCase(ProcTestMixin, TestCase):
    """
    Test all visit combinations for an applicant from dm_ga to dd_u, with a dd_u advocate
    """
    applying_as = const.STATUS_DM_GA
    applying_for = const.STATUS_DD_U
    advocate_status = const.STATUS_DD_U

    def assertAdvsInitial(self):
        self.assertAdvs("fd dam adv am dd_nu dd_u", "dd_u dd_nu")
    def assertAdvsAdv(self):
        self.assertAdvs("fd dam am dd_nu dd_u", "dd_u dd_nu")
    def assertAdvsAdvAM(self):
        self.assertAdvs("fd dam dd_nu dd_u", "dd_u dd_nu")
    def assertAdvsFDDAM(self):
        pass
    def assertAdvsDone(self):
        pass

    def assertPermsInitial(self):
        self.assertPerms("fd dam app", "update_keycheck edit_bio view_person_audit_log")
        self.assertPerms("adv dd_nu dd_u am", "view_person_audit_log")
    def assertPermsAdv(self):
        self.assertPerms("fd dam adv app", "update_keycheck edit_bio view_person_audit_log")
        self.assertPerms("dd_nu dd_u am", "view_person_audit_log")
    def assertPermsAdvAM(self):
        self.assertPerms("fd dam adv am app", "update_keycheck edit_bio view_person_audit_log")
        self.assertPerms("dd_nu dd_u", "view_person_audit_log")
    def assertPermsFDDAM(self):
        self.assertPerms("fd dam", "update_keycheck edit_bio view_person_audit_log")
        self.assertPerms("app", "update_keycheck edit_bio view_person_audit_log")
        self.assertPerms("adv dd_nu dd_u am", "view_person_audit_log")
    def assertPermsDone(self):
        self.assertPerms("fd dam app", "update_keycheck edit_bio view_person_audit_log")
        self.assertPerms("adv dd_nu dd_u am", "view_person_audit_log")