diff --git a/EPAServeur.Tests/Services/ReferentEPTests.cs b/EPAServeur.Tests/Services/ReferentEPTests.cs
new file mode 100644
index 0000000..501d66b
--- /dev/null
+++ b/EPAServeur.Tests/Services/ReferentEPTests.cs
@@ -0,0 +1,224 @@
+using EPAServeur.Context;
+using EPAServeur.Exceptions;
+using EPAServeur.IServices;
+using EPAServeur.Services;
+using IO.Swagger.ApiCollaborateur;
+using IO.Swagger.ClientCollaborateur;
+using IO.Swagger.DTO;
+using Microsoft.EntityFrameworkCore;
+using NUnit.Framework;
+using System;
+using System.Collections.Generic;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace EPAServeur.Tests.Services
+{
+	[TestFixture]
+	public class ReferentEPTests
+	{
+		#region Variables
+		private EpContext context;
+		private ICollaborateurApi collaborateurApi;
+		private ICollaborateurService collaborateurService;
+		private Guid? referent1, referent2, referent3;
+		private Guid? collaborateur1, collaborateur2, collaborateur3;
+		private Guid? collaborateurNonExistant, collaborateurParti;
+		#endregion
+
+		#region SetUp
+		[SetUp]
+		public void SetUp()
+		{
+			// Utilisation d'une base de données en mémoire
+			var optionBuider = new DbContextOptionsBuilder<EpContext>()
+				.UseInMemoryDatabase("server_ep_test")
+				.Options;
+
+			context = new EpContext(optionBuider);
+
+			context.Database.EnsureDeleted();
+			context.Database.EnsureCreated();
+			context.SaveChanges();
+
+			foreach (var entity in context.ChangeTracker.Entries())
+			{
+				entity.State = EntityState.Detached;
+			}
+			collaborateurApi = new CollaborateurApi();
+			collaborateurService = new CollaborateurService(collaborateurApi, context);
+
+
+			referent1 = new Guid("ecf528c3-e509-402f-87bb-c8821467e350");
+			referent2 = new Guid("6aa62dcb-f7c9-4c0c-af40-e934a4d6a7eb");
+			referent3 = new Guid("23d629cd-df09-404a-a6ff-81341db55f29");
+
+			collaborateur1 = new Guid("006226f6-51b2-4a02-a302-7447f7fccc04");
+			collaborateur2 = new Guid("9e1ee839-4477-4d64-9b4d-80654c97c39f");
+			collaborateur3 = new Guid("97e606a1-2fef-4cbf-b6a9-00366fabc412");
+
+			collaborateurNonExistant = new Guid();
+			collaborateurParti = new Guid("3c99214d-0a5e-4bb6-b7b2-7d9bb8143c50");
+
+		}
+		#endregion
+
+		#region Ajout pour un collaborateur
+		
+		[Test]
+		public async Task UpdateReferentUnCollaborateur()
+		{
+			ReferentEPService referentEPService = new ReferentEPService(context, collaborateurApi);
+			CollaborateurDTO collaborateurDTO1 = await collaborateurService.GetCollaborateurByIdAsync(collaborateur1);
+			CollaborateurDTO collaborateurDTO2 = await collaborateurService.GetCollaborateurByIdAsync(collaborateur2);
+			CollaborateurDTO collaborateurDTO3 = await collaborateurService.GetCollaborateurByIdAsync(collaborateur3);
+
+			ReferentEPDTO referentEPDTO1 = new ReferentEPDTO()
+			{
+				IdReferent = referent1,
+				IdsCollaborateur = new List<Guid?>(),
+			};
+			referentEPDTO1.IdsCollaborateur.Add(collaborateur1);
+			
+			ReferentEPDTO referentEPDTO2 = new ReferentEPDTO()
+			{
+				IdReferent = referent2,
+				IdsCollaborateur = new List<Guid?>(),
+			};
+			referentEPDTO2.IdsCollaborateur.Add(collaborateur2);
+			
+			ReferentEPDTO referentEPDTO3 = new ReferentEPDTO()
+			{
+				IdReferent = referent3,
+				IdsCollaborateur = new List<Guid?>(),
+			};
+			referentEPDTO3.IdsCollaborateur.Add(collaborateur3);
+
+			await referentEPService.UpdateReferentCollaborateurAsync(referentEPDTO1, collaborateur1);
+			await referentEPService.UpdateReferentCollaborateurAsync(referentEPDTO2, collaborateur2);
+			await referentEPService.UpdateReferentCollaborateurAsync(referentEPDTO3, collaborateur3);
+
+
+			Assert.IsNotNull(collaborateurDTO1);
+			Assert.IsNull(collaborateurDTO1.Referent);
+			Assert.IsNotNull(collaborateurDTO2);
+			Assert.IsNull(collaborateurDTO2.Referent);
+			Assert.IsNotNull(collaborateurDTO3);
+			Assert.IsNull(collaborateurDTO3.Referent);
+
+			collaborateurDTO1 = await collaborateurService.GetCollaborateurByIdAsync(collaborateur1);
+			collaborateurDTO2 = await collaborateurService.GetCollaborateurByIdAsync(collaborateur2);
+			collaborateurDTO3 = await collaborateurService.GetCollaborateurByIdAsync(collaborateur3);
+
+			Assert.IsNotNull(collaborateurDTO1);
+			Assert.IsNotNull(collaborateurDTO1.Referent);
+			Assert.AreEqual(collaborateurDTO1.Referent.Id, referent1);
+
+			Assert.IsNotNull(collaborateurDTO2);
+			Assert.IsNotNull(collaborateurDTO2.Referent);
+			Assert.AreEqual(collaborateurDTO2.Referent.Id, referent2);
+			
+			Assert.IsNotNull(collaborateurDTO3);
+			Assert.IsNotNull(collaborateurDTO3.Referent);
+			Assert.AreEqual(collaborateurDTO3.Referent.Id, referent3);
+		}
+
+		[Test]
+		public void UpdateReferentCollaborateur_CollaborateurIncompatibleException()
+		{
+			ReferentEPService referentEPService = new ReferentEPService(context, collaborateurApi);
+			ReferentEPDTO referentEPDTO1 = new ReferentEPDTO()
+			{
+				IdReferent = referent1,
+				IdsCollaborateur = new List<Guid?>(),
+			};
+			referentEPDTO1.IdsCollaborateur.Add(collaborateur1);
+
+			ReferentEPDTO referentEPDTO2 = new ReferentEPDTO()
+			{
+				IdReferent = referent1,
+				IdsCollaborateur = new List<Guid?>(),
+			};
+			referentEPDTO2.IdsCollaborateur.Add(null);
+
+			AsyncTestDelegate exception1 = () => referentEPService.UpdateReferentCollaborateurAsync(referentEPDTO1, collaborateur2);
+			Assert.ThrowsAsync(typeof(CollaborateurIncompatibleException), exception1);
+
+			AsyncTestDelegate exception2 = () => referentEPService.UpdateReferentCollaborateurAsync(referentEPDTO2, null);
+			Assert.ThrowsAsync(typeof(CollaborateurIncompatibleException), exception2);
+		}
+
+		[Test]
+		public void UpdateReferentCollaborateur_ReferentNotFoundException()
+		{
+			ReferentEPService referentEPService = new ReferentEPService(context, collaborateurApi);
+			ReferentEPDTO referentEPDTO = new ReferentEPDTO()
+			{
+				IdReferent = collaborateurNonExistant,
+				IdsCollaborateur = new List<Guid?>(),
+			};
+			referentEPDTO.IdsCollaborateur.Add(collaborateur1);
+
+			AsyncTestDelegate exception = () => referentEPService.UpdateReferentCollaborateurAsync(referentEPDTO, collaborateur1);
+			Assert.ThrowsAsync(typeof(ReferentNotFoundException), exception);
+		}
+
+		[Test]
+		public void UpdateReferentCollaborateur_CollaborateurPartiException()
+		{
+			ReferentEPService referentEPService = new ReferentEPService(context, collaborateurApi);
+			ReferentEPDTO referentEPDTO1 = new ReferentEPDTO()
+			{
+				IdReferent = collaborateurParti,
+				IdsCollaborateur = new List<Guid?>(),
+			};
+			referentEPDTO1.IdsCollaborateur.Add(collaborateur1);
+			
+			ReferentEPDTO referentEPDTO2 = new ReferentEPDTO()
+			{
+				IdReferent = collaborateurParti,
+				IdsCollaborateur = new List<Guid?>(),
+			};
+			referentEPDTO2.IdsCollaborateur.Add(collaborateurParti);
+
+			AsyncTestDelegate exception1 = () => referentEPService.UpdateReferentCollaborateurAsync(referentEPDTO1, collaborateur1);
+			AsyncTestDelegate exception2 = () => referentEPService.UpdateReferentCollaborateurAsync(referentEPDTO2, collaborateurParti);
+			Assert.ThrowsAsync(typeof(CollaborateurPartiException), exception1);
+			Assert.ThrowsAsync(typeof(CollaborateurPartiException), exception2);
+		}
+		
+		[Test]
+		public void UpdateReferentCollaborateur_CollaborateurNotFoundException()
+		{
+			ReferentEPService referentEPService = new ReferentEPService(context, collaborateurApi);
+			ReferentEPDTO referentEPDTO = new ReferentEPDTO()
+			{
+				IdReferent = referent1,
+				IdsCollaborateur = new List<Guid?>(),
+			};
+			referentEPDTO.IdsCollaborateur.Add(collaborateurNonExistant);
+
+			AsyncTestDelegate exception = () => referentEPService.UpdateReferentCollaborateurAsync(referentEPDTO, collaborateurNonExistant);
+			Assert.ThrowsAsync(typeof(CollaborateurNotFoundException), exception);
+		}
+
+		[Test]
+		public void UpdateReferentCollaborateur_ApiException()
+		{
+			ReferentEPService referentEPService = new ReferentEPService(context, collaborateurApi);
+			ReferentEPDTO referentEPDTO = new ReferentEPDTO()
+			{
+				IdReferent = null,
+				IdsCollaborateur = new List<Guid?>(),
+			};
+			referentEPDTO.IdsCollaborateur.Add(collaborateur1);
+		
+
+			AsyncTestDelegate exception = () => referentEPService.UpdateReferentCollaborateurAsync(referentEPDTO, collaborateur1);
+			Assert.ThrowsAsync(typeof(ApiException), exception);
+		}
+
+
+		#endregion
+	}
+}
diff --git a/EPAServeur/Controllers/ReferentsEPApi.cs b/EPAServeur/Controllers/ReferentsEPApi.cs
index 17d60ab..952f0ad 100644
--- a/EPAServeur/Controllers/ReferentsEPApi.cs
+++ b/EPAServeur/Controllers/ReferentsEPApi.cs
@@ -234,8 +234,8 @@ namespace IO.Swagger.Controllers
                 };
                 return StatusCode(500, erreur);
             }
-            catch (ReferentIncompatibleException e)
-            {
+            catch(ListeIdsCollaborateursVideException e)
+			{
                 ErreurDTO erreur = new ErreurDTO
                 {
                     Code = 415,
diff --git a/EPAServeur/Services/ReferentEPService.cs b/EPAServeur/Services/ReferentEPService.cs
index c0a3fc5..6115daf 100644
--- a/EPAServeur/Services/ReferentEPService.cs
+++ b/EPAServeur/Services/ReferentEPService.cs
@@ -61,7 +61,7 @@ namespace EPAServeur.Services
 		public async Task<ReferentEPDTO> UpdateReferentCollaborateurAsync(ReferentEPDTO body, Guid? idCollaborateur)
 		{
 			CheckCollaborateurId(idCollaborateur, body);
-
+			CheckListesIdsCollaborateurs(body.IdsCollaborateur);
 
 			Collaborateur referent = await collaborateurApi.ChercherCollabIdAsync(body.IdReferent);
 			CheckReferentValide(referent);
@@ -143,7 +143,7 @@ namespace EPAServeur.Services
 		private void CheckCollaborateurId(Guid? idCollaborateur, ReferentEPDTO body) {
 			if (!body.IdsCollaborateur[0].HasValue || !idCollaborateur.Value.Equals(body.IdsCollaborateur[0].Value))
 			{
-				throw new CollaborateurIncompatibleException("Les données du collaborateur ne correspondent pas");
+				throw new CollaborateurIncompatibleException("Les ids du collaborateur ne correspondent pas ou sont nulls");
 			}
 		}
 		
@@ -169,6 +169,12 @@ namespace EPAServeur.Services
 				CheckCollaborateurValide(c);
 			}
 		}
+		
+		private void CheckListesIdsCollaborateurs(IEnumerable<Guid?> idsCollaborateurs)
+		{
+			if (idsCollaborateurs == null || idsCollaborateurs.Count() == 0)
+				throw new ListeIdsCollaborateursVideException("La liste des collaborateurs ne peut pas être vide");
+		}
 
 		#endregion