from django.urls import reverse
from rest_framework import status
from rest_framework.test import APIClient, APITestCase

from ...models import (Administre, CustomUser, Decision, DecisionChoices,
                       Domaine, Filiere, FormationEmploi, Garnison, Poste,
                       RefGest, RefOrg, RefSvFil, SousVivier)


class TestSocleVerifDroits(APITestCase):
    """ Classe permettant de tester la vérification des droits de lecture et d'écriture d'un gestionnaire """
    @classmethod
    def setUpClass(cls):
        super().setUpClass()

        # Création des gestionnaires
        cls.gest1 = CustomUser.objects.create(username='gest1', password='password', id=1)
        cls.gest2 = CustomUser.objects.create(username='gest2', password='password', id=2)
        cls.gest3 = CustomUser.objects.create(username='gest3', password='password', id=3)
        cls.gest4 = CustomUser.objects.create(username='gest4', password='password', id=4)
        cls.gest5 = CustomUser.objects.create(username='gest5', password='password', id=5)
        cls.gest6 = CustomUser.objects.create(username='gest6', password='password', id=6)
        cls.gest7 = CustomUser.objects.create(username='gest7', password='password', id=7)
        cls.gest8 = CustomUser.objects.create(username='gest8', password='password', id=8)
        cls.gest9 = CustomUser.objects.create(username='gest9', password='password', id=9)
        cls.gest10 = CustomUser.objects.create(username='gest10', password='password', id=10)


        # Création des objets du référentiel organique
        cls.ref_org30 = RefOrg.objects.create(
            ref_org_code='org30',
            ref_org_code_niv_org3='org30',
            ref_org_ref_fe=True,
            ref_org_ref_sv_fil=True,
            ref_org_itd=True,
            ref_org_droit_lect=True,
            ref_org_droit_ecr=True
        )  # Référentiel organique avec les droits de lecture et d'écriture (attribué aux gestionnaires 1)

        cls.ref_org40a = RefOrg.objects.create(
            ref_org_code='org40a',
            ref_org_code_niv_org3='org30',
            ref_org_code_niv_org4='org40a',
            ref_org_ref_fe=True,
            ref_org_ref_sv_fil=True,
            ref_org_itd=True,
            ref_org_droit_lect=True,
            ref_org_droit_ecr=True
        )

        cls.ref_org40b = RefOrg.objects.create(
            ref_org_code='org40b',
            ref_org_code_niv_org3='org30',
            ref_org_code_niv_org4='org40b',
            ref_org_ref_fe=True,
            ref_org_ref_sv_fil=True,
            ref_org_itd=True,
            ref_org_droit_lect=True,
            ref_org_droit_ecr=True
        )

        cls.ref_org41 = RefOrg.objects.create(
            ref_org_code='org41',
            ref_org_code_niv_org4='org41',
            ref_org_ref_fe=True,
            ref_org_ref_sv_fil=True
        )  # Référentiel organique sans les droits de lecture et d'écriture (attribué aux gestionnaires 3)

        cls.ref_org42 = RefOrg.objects.create(
            ref_org_code='org42',
            ref_org_code_niv_org4='org42',
            ref_org_droit_lect=True
        )  # Référentiel organique avec les droits de lecture mais ni pcp ni fil ni itd (attribué aux gestionnaires 4)

        cls.ref_org43 = RefOrg.objects.create(
            ref_org_code='org43',
            ref_org_code_niv_org4='org43',
            ref_org_ref_fe=True,
            ref_org_ref_sv_fil=True,
            ref_org_droit_lect=True,
            ref_org_droit_ecr=True
        )

        cls.ref_org44 = RefOrg.objects.create(
            ref_org_code='org44',
            ref_org_code_niv_org4='org44',
            ref_org_ref_fe=True,
            ref_org_ref_sv_fil=True,
            ref_org_droit_lect=True
        )  # Référentiel organique sans les droits d'écriture (attribué aux gestionnaires 6)

        cls.ref_org45 = RefOrg.objects.create(
            ref_org_code='org45',
            ref_org_code_niv_org4='org45',
            ref_org_ref_fe=True,
            ref_org_ref_sv_fil=True,
            ref_org_droit_lect=True,
            ref_org_droit_ecr=True
        )  # Référentiel organique sans FE ni FIL (attribué aux gestionnaires 7)

        cls.ref_org36 = RefOrg.objects.create(
            ref_org_code='org36',
            ref_org_code_niv_org3='org36',
            ref_org_ref_fe=True,
            ref_org_ref_sv_fil=True,
            ref_org_droit_lect=True,
            ref_org_droit_ecr=True
        )  # Référentiel organique ne possedant aucune instances dans les ref FE et FIL (attribué aux gestionnaires 8)

        cls.ref_org37 = RefOrg.objects.create(
            ref_org_code='org37',
            ref_org_code_niv_org3='org37',
            ref_org_ref_fe=True,
            ref_org_ref_sv_fil=True,
            ref_org_droit_lect=True,
            ref_org_droit_ecr=True
        )

        cls.ref_org47a = RefOrg.objects.create(
            ref_org_code='org47a',
            ref_org_code_niv_org3='org37',
            ref_org_code_niv_org4='org47a',
            ref_org_ref_fe=True,
            ref_org_ref_sv_fil=True,
            ref_org_droit_lect=True,
            ref_org_droit_ecr=True
        )

        cls.ref_org47b = RefOrg.objects.create(
            ref_org_code='org47b',
            ref_org_code_niv_org3='org37',
            ref_org_code_niv_org4='org47b',
            ref_org_ref_fe=True,
            ref_org_ref_sv_fil=True,
            ref_org_droit_lect=True,
            ref_org_droit_ecr=True
        )

        cls.ref_org48 = RefOrg.objects.create(
            ref_org_code='org48',
            ref_org_code_niv_org4='org48',
            ref_org_itd=True,
            ref_org_droit_lect=True,
            ref_org_droit_ecr=True
        )  # Référentiel organique avec tous les droits mais seulement pour un gestionnaire ITD (attribué au gestionnaire 10)


        # Création des objets du référentiel gestionnaire
        cls.ref_gest1 = RefGest.objects.create(ref_gest_sap=cls.gest1.id, ref_gest_org=cls.ref_org30)
        cls.ref_gest2 = RefGest.objects.create(ref_gest_sap=cls.gest2.id)  # Gestionnaire ne possedant pas de cod_niv_org
        cls.ref_gest3 = RefGest.objects.create(ref_gest_sap=cls.gest3.id, ref_gest_org=cls.ref_org41)
        cls.ref_gest4 = RefGest.objects.create(ref_gest_sap=cls.gest4.id, ref_gest_org=cls.ref_org42)
        cls.ref_gest5 = RefGest.objects.create(ref_gest_sap=cls.gest5.id, ref_gest_org=cls.ref_org43)
        cls.ref_gest6 = RefGest.objects.create(ref_gest_sap=cls.gest6.id, ref_gest_org=cls.ref_org44)
        cls.ref_gest7 = RefGest.objects.create(ref_gest_sap=cls.gest7.id, ref_gest_org=cls.ref_org45)
        cls.ref_gest8 = RefGest.objects.create(ref_gest_sap=cls.gest8.id, ref_gest_org=cls.ref_org36)
        cls.ref_gest9 = RefGest.objects.create(ref_gest_sap=cls.gest9.id, ref_gest_org=cls.ref_org37)
        cls.ref_gest10 = RefGest.objects.create(ref_gest_sap=cls.gest10.id, ref_gest_org=cls.ref_org48)

        # Création du référentiel FE et des DOM/FIL
        cls.gar1 = Garnison.objects.create(gar_id='Gar1', gar_lieu='lieu1')
        cls.fe1 = FormationEmploi.objects.create(fe_code='Fe1', fe_code_niv_org4='org40a', fe_garnison_lieu=cls.gar1.gar_lieu)
        cls.fe2 = FormationEmploi.objects.create(fe_code='Fe2', fe_code_niv_org4='org43', fe_garnison_lieu=cls.gar1.gar_lieu)
        cls.fe3 = FormationEmploi.objects.create(fe_code='Fe3', fe_code_niv_org4='org47a', fe_garnison_lieu=cls.gar1.gar_lieu)

        cls.dom1 = Domaine.objects.create(d_code='Dom1')
        cls.fil1 = Filiere.objects.create(f_code='Fil1')


        # Création des administrés, postes et décisions
        cls.adm1 = Administre.objects.create(a_id_sap=1, formation_emploi=cls.fe1, a_domaine=cls.dom1, a_filiere=cls.fil1, a_categorie='Cat1', a_nom='nom', a_prenom='prénom', a_sexe='M', a_eip='eip1')  # Administré du fe1
        cls.adm2 = Administre.objects.create(a_id_sap=2, formation_emploi=cls.fe1, a_domaine=cls.dom1, a_filiere=cls.fil1, a_categorie='Cat1', a_nom='nom', a_prenom='prénom', a_sexe='M', a_eip='eip2')  # Idem
        cls.adm3 = Administre.objects.create(a_id_sap=3, formation_emploi=cls.fe2, a_domaine=cls.dom1, a_filiere=cls.fil1, a_categorie='Cat1', a_nom='nom', a_prenom='prénom', a_sexe='M', a_eip='eip3')  # Administré du fe2
        cls.adm4 = Administre.objects.create(a_id_sap=4, formation_emploi=cls.fe2, a_domaine=cls.dom1, a_filiere=cls.fil1, a_categorie='Cat1', a_nom='nom', a_prenom='prénom', a_sexe='M', a_eip='eip4')  # Idem

        cls.poste1 = Poste.objects.create(p_id='Poste1', formation_emploi=cls.fe1, p_domaine=cls.dom1, p_filiere=cls.fil1, p_categorie='Cat1', p_eip='eip1')
        cls.poste2 = Poste.objects.create(p_id='Poste2', formation_emploi=cls.fe1, p_domaine=cls.dom1, p_filiere=cls.fil1, p_categorie='Cat1', p_eip='eip2')
        cls.poste3 = Poste.objects.create(p_id='Poste3', formation_emploi=cls.fe2, p_domaine=cls.dom1, p_filiere=cls.fil1, p_categorie='Cat1', p_eip='eip3')
        cls.poste4 = Poste.objects.create(p_id='Poste4', formation_emploi=cls.fe2, p_domaine=cls.dom1, p_filiere=cls.fil1, p_categorie='Cat1', p_eip='eip4')
        cls.poste5 = Poste.objects.create(p_id='Poste5', p_specifique='ITD', p_eip='eip5')

        cls.dec1 = Decision.objects.create(administre=cls.adm1, poste=cls.poste1, de_decision=DecisionChoices.PROPOSITION_FE)
        cls.dec2 = Decision.objects.create(administre=cls.adm3, poste=cls.poste3, de_decision=DecisionChoices.PROPOSITION_FE)

        # Création du référentiel sous-vivier filiere
        cls.ref_sv_fil1 = RefSvFil.objects.create(ref_sv_fil_code='org40b', ref_sv_fil_dom='Dom1', ref_sv_fil_fil='Fil1', ref_sv_fil_cat='Cat1')


        # Création des clients de test
        cls.c0 = APIClient()  # Client de test qui ne sera pas authentifié
        cls.c1 = APIClient()
        cls.c2 = APIClient()
        cls.c3 = APIClient()
        cls.c4 = APIClient()
        cls.c5 = APIClient()
        cls.c6 = APIClient()
        cls.c7 = APIClient()
        cls.c8 = APIClient()
        cls.c9 = APIClient()
        cls.c10 = APIClient()

        # Authentification des clients de test
        cls.c1.force_authenticate(cls.gest1)
        cls.c2.force_authenticate(cls.gest2)
        cls.c3.force_authenticate(cls.gest3)
        cls.c4.force_authenticate(cls.gest4)
        cls.c5.force_authenticate(cls.gest5)
        cls.c6.force_authenticate(cls.gest6)
        cls.c7.force_authenticate(cls.gest7)
        cls.c8.force_authenticate(cls.gest8)
        cls.c9.force_authenticate(cls.gest9)
        cls.c10.force_authenticate(cls.gest10)

        cls.list_clients = [cls.c1, cls.c2, cls.c3, cls.c4, cls.c5, cls.c6, cls.c7, cls.c8, cls.c9, cls.c10]

        # Création des données utilsées pour les requêtes
        cls.patch_datas = {
            'data_p1': {
                'p_id': 'Poste1',
                'p_eip': 'eip2'
            },
            'data_a1': {
                'a_id_sap': 1,
                'a_eip': 'eip2'
            },
            'data_d1': {
                'pk': cls.adm1.pk,
                'de_decision': DecisionChoices.POSITIONNE
            },
            'data_p3': {
                'p_id': 'Poste3',
                'p_eip': 'eip4'
            },
            'data_a3': {
                'a_id_sap': 3,
                'a_eip': 'eip4'
            },
            'data_d3': {
                'pk': cls.adm3.pk,
                'de_decision': DecisionChoices.POSITIONNE
            },
            'data_p5': {
                'p_id': 'Poste5',
                'p_eip': 'eip6'
            }
        }

        cls.put_datas = {
            'data_p1': [
                {'p_id': 'Poste1',
                'p_eip': 'eip2'
                },
                {'p_id': 'Poste2',
                'p_eip': 'eip3'
                }
            ],
            'data_a1': [
                {'a_id_sap': 1,
                'a_eip': 'eip2'
                },
                {'a_id_sap': 2,
                'a_eip': 'eip3'
                },
            ],
            'data_p3': [
                {'p_id': 'Poste3',
                'p_eip': 'eip4'
                },
                {'p_id': 'Poste4',
                'p_eip': 'eip5'
                }
            ],
            'data_a3': [
                {'a_id_sap': 3,
                'a_eip': 'eip4'
                },
                {'a_id_sap': 4,
                'a_eip': 'eip5'
                },
            ]
        }


        # Définition des liens sur lesquels les requêtes seront effectuées
        cls.urls = {
            'list_p': reverse('Poste-list'),
            'list_a': reverse('Administre-list'),
            'list_d': reverse('Decision-list'),
            'instance_p1': reverse('Poste-list') + 'Poste1/',
            'instance_a1': reverse('Administre-list') + '1/',
            'instance_d1': reverse('Decision-list') + '1/',
            'instance_p3': reverse('Poste-list') + 'Poste3/',
            'instance_a3': reverse('Administre-list') + '3/',
            'instance_d3': reverse('Decision-list') + '3/',
            'instance_p5': reverse('Poste-list') + 'Poste5/'
        }

    @classmethod
    def tearDownClass(cls):
        super().tearDownClass()
        for client in cls.list_clients:
            client.logout()


    def test_get_not_authenticated(self):
        """
        Teste la requete GET sur les vues PosteView, AdministreView et DecisionView sachant que le gestionnaire n'est pas authentifié
        """
        # Le test passe mais il y a également interdiction car c5 n'a pas de 'code_niv_org'...
        get_resp_p = self.c0.get(path=self.urls['list_p'], follow=True)
        get_resp_a = self.c0.get(path=self.urls['list_a'], follow=True)
        get_resp_d = self.c0.get(path=self.urls['list_d'], follow=True)
        self.assertEqual(get_resp_p.status_code, status.HTTP_403_FORBIDDEN)
        self.assertEqual(get_resp_a.status_code, status.HTTP_403_FORBIDDEN)
        self.assertEqual(get_resp_d.status_code, status.HTTP_403_FORBIDDEN)

    def test_get_ok(self):
        """
        Teste la requete GET sur les vues PosteView, AdministreView et DecisionView sachant que :
        - Le gestionnaire est authentifié,
        - Qu'il a les droits de lecture
        """
        get_resp_p = self.c1.get(path=self.urls['list_p'], follow=True)
        get_resp_a = self.c1.get(path=self.urls['list_a'], follow=True)
        get_resp_d = self.c1.get(path=self.urls['list_d'], follow=True)
        self.assertEqual(get_resp_p.status_code, status.HTTP_200_OK)
        self.assertEqual(get_resp_a.status_code, status.HTTP_200_OK)
        self.assertEqual(get_resp_d.status_code, status.HTTP_200_OK)

    def test_get_no_code_niv_org(self):
        """
        Teste la requete GET sur les vues PosteView, AdministreView et DecisionView sachant que le gestionnaire n'a pas d'attribut code_niv_org
        """
        get_resp_p = self.c2.get(path=self.urls['list_p'], follow=True)
        get_resp_a = self.c2.get(path=self.urls['list_a'], follow=True)
        get_resp_d = self.c2.get(path=self.urls['list_d'], follow=True)
        self.assertEqual(get_resp_p.status_code, status.HTTP_403_FORBIDDEN)
        self.assertEqual(get_resp_a.status_code, status.HTTP_403_FORBIDDEN)
        self.assertEqual(get_resp_d.status_code, status.HTTP_403_FORBIDDEN)

    def test_get_no_reading_rights(self):
        """
        Teste la requete GET sur les vues PosteView, AdministreView et DecisionView sachant que le gestionnaire n'a pas les droits de lecture
        """
        get_resp_p = self.c3.get(path=self.urls['list_p'], follow=True)
        get_resp_a = self.c3.get(path=self.urls['list_a'], follow=True)
        get_resp_d = self.c3.get(path=self.urls['list_d'], follow=True)
        self.assertEqual(get_resp_p.status_code, status.HTTP_403_FORBIDDEN)
        self.assertEqual(get_resp_a.status_code, status.HTTP_403_FORBIDDEN)
        self.assertEqual(get_resp_d.status_code, status.HTTP_403_FORBIDDEN)

    def test_get_not_pcp_not_fil(self):
        """
        Teste la requete GET sur les vues PosteView, AdministreView et DecisionView sachant que le gestionnaire est ni pcp ni filiere
        """
        get_resp_p = self.c4.get(path=self.urls['list_p'], follow=True)
        get_resp_a = self.c4.get(path=self.urls['list_a'], follow=True)
        get_resp_d = self.c4.get(path=self.urls['list_d'], follow=True)
        self.assertEqual(get_resp_p.status_code, status.HTTP_403_FORBIDDEN)
        self.assertEqual(get_resp_a.status_code, status.HTTP_403_FORBIDDEN)
        self.assertEqual(get_resp_d.status_code, status.HTTP_403_FORBIDDEN)

    def test_put_ok_fe_fil(self):
        """
        Teste la requete PUT sur des postes et des administrés sachant que :
        - Le gestionnaire est authentifié,
        - Qu'il a les droits de lecture et d'écriture,
        - Qu'il est PCP et FIL,
        - Qu'il est associé à deux code_niv_org4,
        - Les instances qu'il édite sont dans son FE et dans sa filiere
        """
        # Pas de test put pour les décisions car la modification de plusieurs décisions n'est pas possible dans Ogure
        put_resp_p = self.c1.put(path=self.urls['list_p'], data=self.put_datas['data_p1'], follow=True)
        put_resp_a = self.c1.put(path=self.urls['list_a'], data=self.put_datas['data_a1'], follow=True)
        self.assertEqual(put_resp_p.status_code, status.HTTP_200_OK)
        self.assertEqual(put_resp_a.status_code, status.HTTP_200_OK)

    def test_put_ok_fe(self):
        """
        Teste la requete PUT sur des postes et des administrés sachant que :
        - Le gestionnaire est authentifié,
        - Qu'il a les droits de lecture et d'écriture,
        - Qu'il est PCP et FIL,
        - Qu'il est associé à un code_niv_org4,
        - Les instances qu'il édite sont dans son FE MAIS PAS dans sa FIL
        """
        # Pas de test put pour les décisions car la modification de plusieurs décisions n'est pas possible dans Ogure
        put_resp_p = self.c5.put(path=self.urls['list_p'], data=self.put_datas['data_p3'], follow=True)
        put_resp_a = self.c5.put(path=self.urls['list_a'], data=self.put_datas['data_a3'], follow=True)
        self.assertEqual(put_resp_p.status_code, status.HTTP_200_OK)
        self.assertEqual(put_resp_a.status_code, status.HTTP_200_OK)

    def test_put_no_writing_rights(self):
        """
        Teste la requete PUT sur des postes et des administrés sachant qu'il n'a pas les droits d'écriture'
        """
        put_resp_p = self.c6.put(path=self.urls['list_p'], data=self.put_datas['data_p1'], follow=True)
        put_resp_a = self.c6.put(path=self.urls['list_a'], data=self.put_datas['data_a1'], follow=True)
        self.assertEqual(put_resp_p.status_code, status.HTTP_403_FORBIDDEN)
        self.assertEqual(put_resp_a.status_code, status.HTTP_403_FORBIDDEN)

    def test_put_no_fe_no_fil(self):
        """
        Teste la requete PUT sur des postes et des administrés sachant qu'il n'a pas de FE ni de FIL associé'
        """
        put_resp_p = self.c7.put(path=self.urls['list_p'], data=self.put_datas['data_p1'], follow=True)
        put_resp_a = self.c7.put(path=self.urls['list_a'], data=self.put_datas['data_a1'], follow=True)
        self.assertEqual(put_resp_p.status_code, status.HTTP_403_FORBIDDEN)
        self.assertEqual(put_resp_a.status_code, status.HTTP_403_FORBIDDEN)

    def test_put_no_instances_ok(self):
        """
        Teste la requete PUT sur des postes et des administrés sachant qu'il n'a pas d'instances dans son FE ou dans sa FIL
        """
        put_resp_p = self.c8.put(path=self.urls['list_p'], data=self.put_datas['data_p1'], follow=True)
        put_resp_a = self.c8.put(path=self.urls['list_a'], data=self.put_datas['data_a1'], follow=True)
        self.assertEqual(put_resp_p.status_code, status.HTTP_403_FORBIDDEN)
        self.assertEqual(put_resp_a.status_code, status.HTTP_403_FORBIDDEN)

    def test_put_not_ok(self):
        """
        Teste la requete PUT sur des postes et des administrés sachant que les instances modifiées ne sont ni dans le FE ni dans la FIL du gestionnaire
        """
        put_resp_p = self.c9.put(path=self.urls['list_p'], data=self.put_datas['data_p1'], follow=True)
        put_resp_a = self.c9.put(path=self.urls['list_a'], data=self.put_datas['data_a1'], follow=True)
        self.assertEqual(put_resp_p.status_code, status.HTTP_403_FORBIDDEN)
        self.assertEqual(put_resp_a.status_code, status.HTTP_403_FORBIDDEN)

    def test_patch_no_code_niv_org(self):
        """
        Teste la requete PATCH sur les vues PosteView, AdministreView et DecisionView sachant que le gestionnaire n'a pas d'attribut code_niv_org
        """
        patch_resp_p = self.c2.patch(path=self.urls['instance_p1'], data=self.patch_datas['data_p1'], follow=True)
        patch_resp_a = self.c2.patch(path=self.urls['instance_a1'], data=self.patch_datas['data_a1'], follow=True)
        patch_resp_d = self.c2.patch(path=self.urls['instance_d1'], data=self.patch_datas['data_d1'], follow=True)
        self.assertEqual(patch_resp_p.status_code, status.HTTP_403_FORBIDDEN)
        self.assertEqual(patch_resp_a.status_code, status.HTTP_403_FORBIDDEN)
        self.assertEqual(patch_resp_d.status_code, status.HTTP_403_FORBIDDEN)

    def test_patch_no_reading_rights(self):
        """
        Teste la requete PATCH sur les vues PosteView, AdministreView et DecisionView sachant que le gestionnaire n'a pas les droits de lecture
        """
        patch_resp_p = self.c3.patch(path=self.urls['instance_p1'], data=self.patch_datas['data_p1'], follow=True)
        patch_resp_a = self.c3.patch(path=self.urls['instance_a1'], data=self.patch_datas['data_a1'], follow=True)
        patch_resp_d = self.c3.patch(path=self.urls['instance_d1'], data=self.patch_datas['data_d1'], follow=True)
        self.assertEqual(patch_resp_p.status_code, status.HTTP_403_FORBIDDEN)
        self.assertEqual(patch_resp_a.status_code, status.HTTP_403_FORBIDDEN)
        self.assertEqual(patch_resp_d.status_code, status.HTTP_403_FORBIDDEN)

    def test_patch_not_pcp_not_fil_not_itd(self):
        """
        Teste la requete PATCH sur les vues PosteView, AdministreView et DecisionView sachant que le gestionnaire est ni pcp ni filiere
        """
        patch_resp_p = self.c4.patch(path=self.urls['instance_p1'], data=self.patch_datas['data_p1'], follow=True)
        patch_resp_a = self.c4.patch(path=self.urls['instance_a1'], data=self.patch_datas['data_a1'], follow=True)
        patch_resp_d = self.c4.patch(path=self.urls['instance_d1'], data=self.patch_datas['data_d1'], follow=True)
        self.assertEqual(patch_resp_p.status_code, status.HTTP_403_FORBIDDEN)
        self.assertEqual(patch_resp_a.status_code, status.HTTP_403_FORBIDDEN)
        self.assertEqual(patch_resp_d.status_code, status.HTTP_403_FORBIDDEN)

    def test_patch_ok_fe_fil(self):
        """
        Teste la requete PATCH sur un poste, un administré et une décision sachant que :
        - Le gestionnaire est authentifié,
        - Qu'il a les droits de lecture et d'écriture,
        - Qu'il est PCP et FIL,
        - Qu'il est associé à deux code_niv_org4,
        - Les instances qu'il édite sont dans son FE et dans sa filiere
        """
        patch_resp_p = self.c1.patch(path=self.urls['instance_p1'], data=self.patch_datas['data_p1'], follow=True)
        patch_resp_a = self.c1.patch(path=self.urls['instance_a1'], data=self.patch_datas['data_a1'], follow=True)
        patch_resp_d = self.c1.patch(path=self.urls['instance_d1'], data=self.patch_datas['data_d1'], follow=True)
        self.assertEqual(patch_resp_p.status_code, status.HTTP_200_OK)
        self.assertEqual(patch_resp_a.status_code, status.HTTP_200_OK)
        self.assertEqual(patch_resp_d.status_code, status.HTTP_200_OK)

    def test_patch_ok_fe(self):
        """
        Teste la requete PATCH sur un poste, un administré et une décision sachant que :
        - Le gestionnaire est authentifié,
        - Qu'il a les droits de lecture et d'écriture,
        - Qu'il est PCP et FIL,
        - Qu'il est associé à un code_niv_org4,
        - Les instances qu'il édite sont dans son FE MAIS PAS dans sa FIL
        """
        patch_resp_p = self.c5.patch(path=self.urls['instance_p3'], data=self.patch_datas['data_p3'], follow=True)
        patch_resp_a = self.c5.patch(path=self.urls['instance_a3'], data=self.patch_datas['data_a3'], follow=True)
        patch_resp_d = self.c5.patch(path=self.urls['instance_d3'], data=self.patch_datas['data_d3'], follow=True)
        self.assertEqual(patch_resp_p.status_code, status.HTTP_200_OK)
        self.assertEqual(patch_resp_a.status_code, status.HTTP_200_OK)
        self.assertEqual(patch_resp_d.status_code, status.HTTP_200_OK)

    def test_patch_ok_itd(self):
        """
        Teste la requete PATCH sur un poste sachant que :
        - Le gestionnaire est authentifié,
        - Qu'il a les droits de lecture et d'écriture,
        - Qu'il est ITD,
        - Qu'il est associé à un code_niv_org4,
        - Le poste édité est marqué ITD
        """
        patch_resp_p = self.c10.patch(path=self.urls['instance_p5'], data=self.patch_datas['data_p5'], follow=True)
        self.assertEqual(patch_resp_p.status_code, status.HTTP_200_OK)

    def test_patch_no_writing_rights(self):
        """
        Teste la requete PATCH sur des postes et des administrés sachant qu'il n'a pas les droits d'écriture'
        """
        patch_resp_p = self.c6.patch(path=self.urls['instance_p1'], data=self.patch_datas['data_p1'], follow=True)
        patch_resp_a = self.c6.patch(path=self.urls['instance_a1'], data=self.patch_datas['data_a1'], follow=True)
        patch_resp_d = self.c6.patch(path=self.urls['instance_d1'], data=self.patch_datas['data_d1'], follow=True)
        self.assertEqual(patch_resp_p.status_code, status.HTTP_403_FORBIDDEN)
        self.assertEqual(patch_resp_a.status_code, status.HTTP_403_FORBIDDEN)
        self.assertEqual(patch_resp_d.status_code, status.HTTP_403_FORBIDDEN)

    def test_patch_no_niv_org(self):
        """
        Teste la requete PATCH sur des postes et des administrés sachant qu'il n'a pas d'attribut niv_org'
        """
        patch_resp_p = self.c7.patch(path=self.urls['instance_p1'], data=self.patch_datas['data_p1'], follow=True)
        patch_resp_a = self.c7.patch(path=self.urls['instance_a1'], data=self.patch_datas['data_a1'], follow=True)
        patch_resp_d = self.c7.patch(path=self.urls['instance_d1'], data=self.patch_datas['data_d1'], follow=True)
        self.assertEqual(patch_resp_p.status_code, status.HTTP_403_FORBIDDEN)
        self.assertEqual(patch_resp_a.status_code, status.HTTP_403_FORBIDDEN)
        self.assertEqual(patch_resp_d.status_code, status.HTTP_403_FORBIDDEN)

    def test_patch_no_instances_ok(self):
        """
        Teste la requete PATCH sur des postes et des administrés sachant qu'il n'a pas d'instances dans son FE ou dans sa FIL
        """
        patch_resp_p = self.c8.patch(path=self.urls['instance_p1'], data=self.patch_datas['data_p1'], follow=True)
        patch_resp_a = self.c8.patch(path=self.urls['instance_a1'], data=self.patch_datas['data_a1'], follow=True)
        patch_resp_d = self.c8.patch(path=self.urls['instance_d1'], data=self.patch_datas['data_d1'], follow=True)
        self.assertEqual(patch_resp_p.status_code, status.HTTP_403_FORBIDDEN)
        self.assertEqual(patch_resp_a.status_code, status.HTTP_403_FORBIDDEN)
        self.assertEqual(patch_resp_d.status_code, status.HTTP_403_FORBIDDEN)

    def test_patch_not_ok_fe_fil(self):
        """
        Teste la requete PATCH sur un poste, un administré et une décision sachant que les instances modifiées ne sont ni dans le FE ni dans la FIL du gestionnaire
        """
        patch_resp_p = self.c9.patch(path=self.urls['instance_p1'], data=self.patch_datas['data_p1'], follow=True)
        patch_resp_a = self.c9.patch(path=self.urls['instance_a1'], data=self.patch_datas['data_a1'], follow=True)
        patch_resp_d = self.c9.patch(path=self.urls['instance_d1'], data=self.patch_datas['data_d1'], follow=True)
        self.assertEqual(patch_resp_p.status_code, status.HTTP_403_FORBIDDEN)
        self.assertEqual(patch_resp_a.status_code, status.HTTP_403_FORBIDDEN)
        self.assertEqual(patch_resp_d.status_code, status.HTTP_403_FORBIDDEN)

    def test_patch_not_ok_itd(self):
        """
        Teste la requete PATCH sur un poste sachant que l'instance modifiée n'est pas marquée ITD
        """
        patch_resp_p = self.c10.patch(path=self.urls['instance_p1'], data=self.patch_datas['data_p1'], follow=True)
        self.assertEqual(patch_resp_p.status_code, status.HTTP_403_FORBIDDEN)

    def test_delete_ok(self):
        delete_resp_p = self.c1.delete(path=self.urls['instance_p1'], follow=True)
        delete_resp_a = self.c1.delete(path=self.urls['instance_a1'], follow=True)
        self.assertEqual(delete_resp_p.status_code, status.HTTP_204_NO_CONTENT)
        self.assertEqual(delete_resp_a.status_code, status.HTTP_204_NO_CONTENT)

    def test_delete_decision_ok(self):
        # On teste la suppression de décision séparément des autres suppressions sans quoi instance_d ferait référence à un administré supprimé
        delete_resp_d = self.c1.delete(path=self.urls['instance_d1'], follow=True)
        self.assertEqual(delete_resp_d.status_code, status.HTTP_204_NO_CONTENT)

    def test_delete_not_ok(self):
        # delete_resp_p = self.c9.delete(path=self.urls['instance_p1'], follow=True)
        # delete_resp_a = self.c9.delete(path=self.urls['instance_a1'], follow=True)
        delete_resp_d = self.c9.delete(path=self.urls['instance_d1'], follow=True)
        # self.assertEqual(delete_resp_p.status_code, status.HTTP_403_FORBIDDEN)
        # self.assertEqual(delete_resp_a.status_code, status.HTTP_403_FORBIDDEN)
        self.assertEqual(delete_resp_d.status_code, status.HTTP_403_FORBIDDEN)

    def test_head_ok(self):
        head_resp_p = self.c1.head(path=self.urls['list_p'], follow=True)
        head_resp_a = self.c1.head(path=self.urls['list_a'], follow=True)
        head_resp_d = self.c1.head(path=self.urls['list_d'], follow=True)
        self.assertEqual(head_resp_p.status_code, status.HTTP_200_OK)
        self.assertEqual(head_resp_a.status_code, status.HTTP_200_OK)
        self.assertEqual(head_resp_d.status_code, status.HTTP_200_OK)

    def test_head_no_reading_rights(self):
        head_resp_p = self.c3.head(path=self.urls['list_p'], follow=True)
        head_resp_a = self.c3.head(path=self.urls['list_a'], follow=True)
        head_resp_d = self.c3.head(path=self.urls['list_d'], follow=True)
        self.assertEqual(head_resp_p.status_code, status.HTTP_403_FORBIDDEN)
        self.assertEqual(head_resp_a.status_code, status.HTTP_403_FORBIDDEN)
        self.assertEqual(head_resp_d.status_code, status.HTTP_403_FORBIDDEN)
