init

backend-django/backend/tests/droits/__init__.py

@@ -0,0 +1 @@
+from .socle import *

backend-django/backend/tests/droits/socle.py

@@ -0,0 +1,590 @@
+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)