Exemple #1
0
    def test_prescriber_organization_one_membership(self):

        organization = PrescriberOrganizationWithMembershipFactory()
        user = organization.members.first()
        self.assertTrue(
            user.prescribermembership_set.get(organization=organization).is_admin
        )

        factory = RequestFactory()
        request = factory.get("/")
        request.user = user
        middleware = SessionMiddleware()
        middleware.process_request(request)
        request.session[
            settings.ITOU_SESSION_CURRENT_PRESCRIBER_ORG_KEY
        ] = organization.pk
        request.session.save()

        with self.assertNumQueries(1):
            result = get_current_organization_and_perms(request)
            expected = {
                "current_prescriber_organization": organization,
                "current_siae": None,
                "user_is_prescriber_org_admin": True,
                "user_is_siae_admin": False,
                "user_siae_set": [],
            }
            self.assertDictEqual(expected, result)
Exemple #2
0
    def test_siae_one_membership(self):

        siae = SiaeWithMembershipFactory()
        user = siae.members.first()
        self.assertTrue(siae.has_admin(user))

        factory = RequestFactory()
        request = factory.get("/")
        request.user = user
        middleware = SessionMiddleware()
        middleware.process_request(request)
        request.session[settings.ITOU_SESSION_CURRENT_SIAE_KEY] = siae.pk
        request.session.save()

        with self.assertNumQueries(1):
            result = get_current_organization_and_perms(request)
            expected = {
                "current_prescriber_organization":
                None,
                "current_siae":
                siae,
                "user_is_prescriber_org_admin":
                False,
                "user_is_siae_admin":
                True,
                "user_siae_set": [siae],
                "matomo_custom_variables":
                OrderedDict([("is_authenticated", "yes"),
                             ("account_type", "employer"),
                             ("account_sub_type", "employer_admin")]),
            }
            self.assertDictEqual(expected, result)
Exemple #3
0
    def test_siae_multiple_memberships(self):

        siae1 = SiaeWithMembershipFactory()
        user = siae1.members.first()
        self.assertTrue(user.siaemembership_set.get(siae=siae1).is_siae_admin)

        siae2 = SiaeFactory()
        siae2.members.add(user)
        self.assertFalse(user.siaemembership_set.get(siae=siae2).is_siae_admin)

        siae3 = SiaeFactory()
        siae3.members.add(user)
        self.assertFalse(user.siaemembership_set.get(siae=siae3).is_siae_admin)

        factory = RequestFactory()
        request = factory.get("/")
        request.user = user
        middleware = SessionMiddleware()
        middleware.process_request(request)
        request.session[settings.ITOU_SESSION_CURRENT_SIAE_KEY] = siae3.pk
        request.session.save()

        with self.assertNumQueries(1):
            result = get_current_organization_and_perms(request)
            expected = {
                "current_prescriber_organization": None,
                "current_siae": siae3,
                "user_is_prescriber_org_admin": False,
                "user_is_siae_admin": False,
                "user_siae_set": [siae1, siae2, siae3],
            }
            self.assertDictEqual(expected, result)
Exemple #4
0
    def test_labor_inspector_multiple_institutions(self):
        institution1 = InstitutionWithMembershipFactory()
        user = institution1.members.first()
        self.assertTrue(user.institutionmembership_set.get(institution=institution1).is_admin)
        institution2 = InstitutionFactory()
        institution2.members.add(user)
        self.assertFalse(institution2.has_admin(user))

        request = self.go_to_dashboard(
            user=user,
            establishment_session_key=settings.ITOU_SESSION_CURRENT_INSTITUTION_KEY,
            establishment_pk=institution2.pk,
        )

        with self.assertNumQueries(1):
            result = get_current_organization_and_perms(request)
            expected = self.default_result | {
                "current_institution": institution2,
                "user_institutions": [institution1, institution2],
                "user_is_institution_admin": False,
                "matomo_custom_variables": OrderedDict(
                    [
                        ("is_authenticated", "yes"),
                        ("account_type", "labor_inspector"),
                        ("account_sub_type", "inspector_not_admin"),
                    ]
                ),
            }
            self.assertDictEqual(expected, result)
Exemple #5
0
    def test_prescriber_organization_multiple_membership(self):

        organization1 = PrescriberOrganizationWithMembershipFactory()
        user = organization1.members.first()
        self.assertTrue(user.prescribermembership_set.get(organization=organization1).is_admin)

        organization2 = PrescriberOrganizationWithMembershipFactory()
        organization2.members.add(user)

        request = self.go_to_dashboard(
            user=user,
            establishment_session_key=settings.ITOU_SESSION_CURRENT_PRESCRIBER_ORG_KEY,
            establishment_pk=organization1.pk,
        )

        with self.assertNumQueries(1):
            result = get_current_organization_and_perms(request)
            expected = self.default_result | {
                "current_prescriber_organization": organization1,
                "user_prescriberorganizations": [organization1, organization2],
                "user_is_prescriber_org_admin": True,
                "matomo_custom_variables": OrderedDict(
                    [
                        ("is_authenticated", "yes"),
                        ("account_type", "prescriber"),
                        ("account_sub_type", "prescriber_with_unauthorized_org"),
                    ]
                ),
            }
            self.assertDictEqual(expected, result)
Exemple #6
0
    def test_siae_multiple_memberships(self):

        siae1 = SiaeWithMembershipFactory()
        user = siae1.members.first()
        self.assertTrue(siae1.has_admin(user))

        siae2 = SiaeFactory()
        siae2.members.add(user)
        self.assertFalse(siae2.has_admin(user))

        request = self.go_to_dashboard(
            user=user, establishment_session_key=settings.ITOU_SESSION_CURRENT_SIAE_KEY, establishment_pk=siae2.pk
        )

        with self.assertNumQueries(1):
            result = get_current_organization_and_perms(request)

            expected = self.default_result | {
                "current_siae": siae2,
                "user_siaes": [siae1, siae2],
                "user_is_siae_admin": False,
                "matomo_custom_variables": OrderedDict(
                    [
                        ("is_authenticated", "yes"),
                        ("account_type", "employer"),
                        ("account_sub_type", "employer_not_admin"),
                    ]
                ),
            }
            self.assertDictEqual(expected, result)
Exemple #7
0
    def test_prescriber_organization_one_membership(self):

        organization = PrescriberOrganizationWithMembershipFactory()
        user = organization.members.first()
        self.assertTrue(
            user.prescribermembership_set.get(
                organization=organization).is_admin)

        factory = RequestFactory()
        request = factory.get("/")
        request.user = user
        middleware = SessionMiddleware()
        middleware.process_request(request)
        request.session[
            settings.ITOU_SESSION_CURRENT_PRESCRIBER_ORG_KEY] = organization.pk
        request.session.save()

        with self.assertNumQueries(1):
            result = get_current_organization_and_perms(request)
            expected = {
                "current_prescriber_organization":
                organization,
                "current_siae":
                None,
                "user_is_prescriber_org_admin":
                True,
                "user_is_siae_admin":
                False,
                "user_siae_set": [],
                "matomo_custom_variables":
                OrderedDict([
                    ("is_authenticated", "yes"),
                    ("account_type", "prescriber"),
                    ("account_sub_type", "prescriber_with_unauthorized_org"),
                ]),
            }
            self.assertDictEqual(expected, result)