Digitalisation_EPA_Serveur/EPAServeur.Tests/Services/CollaborateurServiceTests.cs

using EPAServeur.Context;
using EPAServeur.Exceptions;
using EPAServeur.IServices;
using EPAServeur.Services;
using IO.Swagger.ApiCollaborateur;
using IO.Swagger.DTO;
using Microsoft.EntityFrameworkCore;
using NUnit.Framework;
using System;
using System.Linq;
using System.Collections.Generic;
using System.Text;
using System.Threading.Tasks;

namespace EPAServeur.Tests.Services
{
	[TestFixture]
	public class CollaborateurServiceTests
	{
		#region
		private EpContext context;
		private ICollaborateurApi collaborateurApi;
		private ITransformDTO transformDTO;

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

			// Ajout du jeu de données pour les tests
			DataSeeder.AddRereferentEP(context);

			// Détache les entités du context car la base de données InMemory créé des conflits
			// entre les clés primaires lors d'un Update ou d'un Insert   
			foreach (var entity in context.ChangeTracker.Entries())
			{
				entity.State = EntityState.Detached;
			}
			transformDTO = new TransformDTO();
			collaborateurApi = new CollaborateurApi();
		}
		#endregion

		#region Tests getCollaborateur

		[TestCase("842650db-a548-4472-a3af-4c5fff3c1ab8")]
		[TestCase("301ba7f3-095e-4912-8998-a7c942dc5f23")]
		[TestCase("4f3fcd23-a1e4-4c9e-afa2-d06ca9216491")]
		public async Task GetCollaborateurById_Ok(Guid? id)
		{
			ICollaborateurService collaborateurService = new CollaborateurService(collaborateurApi, context, transformDTO);

			CollaborateurDTO collaborateurDTO = await collaborateurService.GetCollaborateurByIdAsync(id);
			
			Assert.IsNotNull(collaborateurDTO);
			Assert.AreEqual(collaborateurDTO.Id, id);
		}

		[TestCase("creola.nicolas@apside-groupe.com")]
		[TestCase("lamar.rousseau@apside-groupe.com")]
		[TestCase("coty.lemoine@apside-groupe.com")]
		public async Task GetCollaborateurByMail_Ok(string mail)
		{
			ICollaborateurService collaborateurService = new CollaborateurService(collaborateurApi, context, transformDTO);

			CollaborateurDTO collaborateurDTO = await collaborateurService.GetCollaborateurByMailAsync(mail);

			Assert.IsNotNull(collaborateurDTO);
			Assert.AreEqual(collaborateurDTO.MailApside, mail);
		}

		[TestCase("006226f6-51b2-4a02-a302-7447f7fccc04")]
		[TestCase("e5d36da4-df16-4d19-8a11-1ba2f6efc80c")]
		[TestCase("92b29b9c-40a4-4aa0-9412-bc97a379e52f")]
		public void GetCollaborateurById_CollaborateurNotFound(Guid? id)
		{
			ICollaborateurService collaborateurService = new CollaborateurService(collaborateurApi, context, transformDTO);

			AsyncTestDelegate exception = () => collaborateurService.GetCollaborateurByIdAsync(id);
			Assert.ThrowsAsync(typeof(CollaborateurNotFoundException), exception);
		}

		[TestCase("nicolas@apside.fr")]
		[TestCase("rousseau@apside.fr")]
		[TestCase("lemoine@apside.fr")]
		public void GetCollaborateurByMail_CollaborateurNotFound(string mail)
		{
			ICollaborateurService collaborateurService = new CollaborateurService(collaborateurApi, context, transformDTO);

			AsyncTestDelegate exception = () => collaborateurService.GetCollaborateurByMailAsync(mail);
			Assert.ThrowsAsync(typeof(CollaborateurNotFoundException), exception);
		}
		#endregion


		#region Tests GetCollaborateurs Roles
		
		[TestCase("RH")]
		[TestCase("Collaborateur")]
		[TestCase("Assistant")]
		[TestCase("Manager")]
		[TestCase("RA")]
		public async Task GetCollaborateurs_UnRole(string role)
		{
			ICollaborateurService collaborateurService = new CollaborateurService(collaborateurApi, context, transformDTO);

			List<string> roles = new List<string>();
			roles.Add(role);

			IEnumerable<CollaborateurDTO> collaborateurs = await collaborateurService.GetCollaborateursAsync(roles, null, true, 1, 50, "", "", null, null);
			int count = await collaborateurService.GetCollaborateursCountAsync(roles, null, "", null, null);
		
			Assert.AreEqual(count, collaborateurs.Count());

			switch (role)
			{
				case "RH":
					Assert.AreEqual(count, 9);
					break;
				case "Collaborateur":
					Assert.AreEqual(count, 7); 
					break;
				case "Assistant":
					Assert.AreEqual(count, 6); 
					break;
				case "Manager":
					Assert.AreEqual(count, 10); 
					break;
				case "RA":
					Assert.AreEqual(count, 5); 
					break;
			}
		}


		[Test]
		public async Task GetCollaborateurs_RoleRH_RoleAssistant()
		{
			ICollaborateurService collaborateurService = new CollaborateurService(collaborateurApi, context, transformDTO);

			List<string> roles = new List<string>();
			roles.Add("Assistant");
			roles.Add("RH");

			IEnumerable<CollaborateurDTO> collaborateurs = await collaborateurService.GetCollaborateursAsync(roles, null, true, 1, 50, "", "", null, null);
			int count = await collaborateurService.GetCollaborateursCountAsync(roles, null, "", null, null);
			Assert.AreEqual(count, 15); Assert.AreEqual(count, collaborateurs.Count());
		}

		[Test]
		public async Task GetCollaborateurs_RoleRA_RoleManager()
		{
			ICollaborateurService collaborateurService = new CollaborateurService(collaborateurApi, context, transformDTO);

			List<string> roles = new List<string>();
			roles.Add("Manager");
			roles.Add("RA");

			IEnumerable<CollaborateurDTO> collaborateurs = await collaborateurService.GetCollaborateursAsync(roles, null, true, 1, 50, "", "", null, null);
			int count = await collaborateurService.GetCollaborateursCountAsync(roles, null, "", null, null);
			Assert.AreEqual(count, collaborateurs.Count());
			Assert.AreEqual(count, 15);
		}

		#endregion

		#region Test GetCollaborateurs Tri et Pagination

		[Test]
		public async Task GetCollaborateurs_Asc_Desc()
		{
			ICollaborateurService collaborateurService = new CollaborateurService(collaborateurApi, context, transformDTO);

			IEnumerable<CollaborateurDTO> collaborateursAsc = await collaborateurService.GetCollaborateursAsync(null, null, true, 1, 50, "", "", null, null);
			IEnumerable<CollaborateurDTO> collaborateursDesc = await collaborateurService.GetCollaborateursAsync(null, null, false, 1, 50, "", "", null, null);
			CollaborateurDTO collaborateurDTOFirstAsc = collaborateursAsc.First();
			CollaborateurDTO collaborateurDTLastAsc = collaborateursAsc.Last();
			CollaborateurDTO collaborateurDTOFirstDesc = collaborateursDesc.First();
			CollaborateurDTO collaborateurDTLastDesc = collaborateursDesc.Last();

			Assert.AreEqual(collaborateurDTOFirstAsc.Id, collaborateurDTLastDesc.Id);
			Assert.AreEqual(collaborateurDTLastAsc.Id, collaborateurDTOFirstDesc.Id);
		}

		[TestCase("ma")]
		[TestCase("z")]
		[TestCase("em")]
		[TestCase("")]
		public async Task GetCollaborateurs_Texte(string texte)
		{
			ICollaborateurService collaborateurService = new CollaborateurService(collaborateurApi, context, transformDTO);

			IEnumerable<CollaborateurDTO> collaborateurs = await collaborateurService.GetCollaborateursAsync(null, null, true, 1, 50, texte, "", null, null);
			string nomprenom, prenomnom;
			foreach(CollaborateurDTO collaborateur in collaborateurs)
			{
				nomprenom = collaborateur.Nom.ToLower() + " " + collaborateur.Prenom.ToLower();
				prenomnom = collaborateur.Prenom.ToLower() + " " + collaborateur.Nom.ToLower();
				Assert.IsTrue(nomprenom.Contains(texte) || prenomnom.Contains(texte));
			}
		}

		[TestCase(2015,1,1)]
		[TestCase(2016,1,1)]
		[TestCase(2017,1,1)]
		[TestCase(2018,1,1)]
		public async Task GetCollaborateurs_DateDebut(int annee, int mois, int jour)
		{
			ICollaborateurService collaborateurService = new CollaborateurService(collaborateurApi, context, transformDTO);

			DateTime dateDebut = new DateTime(annee, mois, jour);
			IEnumerable<CollaborateurDTO> collaborateurs = await collaborateurService.GetCollaborateursAsync(null, null, true, 1, 50, "", "", dateDebut, null);
			foreach(CollaborateurDTO collaborateur in collaborateurs)
			{
				Assert.IsTrue(collaborateur.DateArrivee >= dateDebut);
			}
		}

		[TestCase(2020, 12, 31)]
		[TestCase(2019, 12, 31)]
		[TestCase(2018, 12, 31)]
		[TestCase(2017, 12, 31)]
		public async Task GetCollaborateurs_DateFin(int annee, int mois, int jour)
		{
			ICollaborateurService collaborateurService = new CollaborateurService(collaborateurApi, context, transformDTO);

			DateTime dateFin = new DateTime(annee, mois, jour);
			IEnumerable<CollaborateurDTO> collaborateurs = await collaborateurService.GetCollaborateursAsync(null, null, true, 1, 50, "", "", null, dateFin);
			foreach (CollaborateurDTO collaborateur in collaborateurs)
			{
				Assert.IsTrue(collaborateur.DateArrivee < dateFin);
			}
		}


		[TestCase(2016,1,1,2018,12,31)]
		[TestCase(2017,6,1,2017,6,30)]
		[TestCase(2019,1,1,2019,12,31)]
		public async Task GetCollaborateurs_DateDebutDateFin(int anneeDeb, int moisDeb, int jourDeb, int anneeFin, int moisFin, int jourFin)
		{
			ICollaborateurService collaborateurService = new CollaborateurService(collaborateurApi, context, transformDTO);

			DateTime dateDebut = new DateTime(anneeDeb, moisDeb, jourDeb);
			DateTime dateFin = new DateTime(anneeFin, moisFin, jourFin);
			IEnumerable<CollaborateurDTO> collaborateurs = await collaborateurService.GetCollaborateursAsync(null, null, true, 1, 50, "", "", dateDebut, dateFin);
			foreach (CollaborateurDTO collaborateur in collaborateurs)
			{
				Assert.IsTrue(collaborateur.DateArrivee >= dateDebut && collaborateur.DateArrivee < dateFin);
			}
		}


		
		[TestCase(1,15)]
		[TestCase(4,5)]
		[TestCase(2,15)]
		[TestCase(1,20)]
		[TestCase(1,37)]
		public async Task GetCollaborateur_Paginaion(int numPage, int parPage)
		{
			ICollaborateurService collaborateurService = new CollaborateurService(collaborateurApi, context, transformDTO);

			IEnumerable<CollaborateurDTO> collaborateurs = await collaborateurService.GetCollaborateursAsync(null, null, true, numPage, parPage, "", "", null, null);
			Assert.AreEqual(collaborateurs.Count(), parPage);
		}

		[TestCase(2, 37, 0)]
		[TestCase(3, 15, 7)]
		[TestCase(8, 5, 2)]
		public async Task GetCollaborateur_Paginaion_2(int numPage, int parPage, int res)
		{
			ICollaborateurService collaborateurService = new CollaborateurService(collaborateurApi, context, transformDTO);

			IEnumerable<CollaborateurDTO> collaborateurs = await collaborateurService.GetCollaborateursAsync(null, null, true, numPage, parPage, "", "", null, null);
			Assert.AreEqual(collaborateurs.Count(), res);
		}

		[TestCase(0, 4)]
		[TestCase(-1, 0)]
		[TestCase(-10, -10)]
		[TestCase(-10, 20)]
		[TestCase(-1, 37)]
		public async Task GetCollaborateur_PaginaionValeursParDefaut(int numPage, int parPage)
		{
			ICollaborateurService collaborateurService = new CollaborateurService(collaborateurApi, context, transformDTO);

			IEnumerable<CollaborateurDTO> collaborateurs = await collaborateurService.GetCollaborateursAsync(null, null, true, numPage, parPage, "", "", null, null);
			
			if(parPage < 5)
				Assert.AreEqual(collaborateurs.Count(), 15);
			else
				Assert.AreEqual(collaborateurs.Count(), parPage);
		}


		[Test]
		public async Task GetCollaborateur_OrderByDateArrive()
		{
			ICollaborateurService collaborateurService = new CollaborateurService(collaborateurApi, context, transformDTO);

			IEnumerable<CollaborateurDTO> collaborateurs = await collaborateurService.GetCollaborateursAsync(null, null, true, 1, 30, "", "datearrivee", null, null);
			DateTime d1, d2;
			for(int i = 0; i < collaborateurs.Count() -1; ++i)
			{
				d1 = collaborateurs.ElementAt(i).DateArrivee.Value;
				d2 = collaborateurs.ElementAt(i+1).DateArrivee.Value;
				Assert.AreEqual(DateTime.Compare(d1, d2),-1);
			}
		
		}


		[Test]
		public async Task GetCollaborateur_OrderByBU()
		{
			ICollaborateurService collaborateurService = new CollaborateurService(collaborateurApi, context, transformDTO);

			IEnumerable<CollaborateurDTO> collaborateurs = await collaborateurService.GetCollaborateursAsync(null, null, true, 1, 30, "", "businessunit", null, null);
			string bu1, bu2;
			for (int i = 0; i < collaborateurs.Count() - 1; ++i)
			{
				bu1 = collaborateurs.ElementAt(i).BusinessUnit.Nom;
				bu2 = collaborateurs.ElementAt(i + 1).BusinessUnit.Nom;
				Console.WriteLine(bu1 + " " + bu2);
				Assert.IsTrue(string.Compare(bu1, bu2) <= 0);
			}

		}


		[Test]
		public async Task GetCollaborateur_OrderByNom()
		{
			ICollaborateurService collaborateurService = new CollaborateurService(collaborateurApi, context, transformDTO);

			IEnumerable<CollaborateurDTO> collaborateurs = await collaborateurService.GetCollaborateursAsync(null, null, true, 1, 30, "", "collaborateur", null, null);
			string nom1, nom2;
			for (int i = 0; i < collaborateurs.Count() - 1; ++i)
			{
				nom1 = collaborateurs.ElementAt(i).Nom;
				nom2 = collaborateurs.ElementAt(i+1).Nom;
				Assert.IsTrue(string.Compare(nom1, nom2) <= 0);
			}

		}
		#endregion

		#region GetCollaborateurs par referent
		[TestCase("aa36f34c-9041-42f5-9db3-6536fe7f1696")]
		[TestCase("01ee85ff-d7f3-494b-b1de-26ced8fbfa0d")]
		[TestCase("e7820f92-eab1-42f5-ae96-5c16e71ff1e6")]
		[TestCase("de98a866-736f-4295-a669-92a8694e2ee3")]
		[TestCase("642bc07f-051a-4088-8a73-425b44998673")]
		public async Task GetCollaborateurByReferentPlusCount(Guid idReferent)
		{
			ICollaborateurService collaborateurService = new CollaborateurService(collaborateurApi, context, transformDTO);

			IEnumerable<CollaborateurDTO> collaborateurs = await collaborateurService.GetCollaborateursByReferentAsync(idReferent, true, 1, 15, "", "");
			int count = await collaborateurService.GetCollaborateursCountByReferentAsync(idReferent, "");
			Assert.AreEqual(count, collaborateurs.Count());
		}


		[TestCase("8a68e248-65f8-11eb-ae93-0242ac130002")]
		[TestCase("c43a975f-2b83-423b-96e5-ff98c6bd5bd3")]
		[TestCase("e6b66b62-9ddb-423e-8f58-0a647514ecfe")]
		[TestCase("ca1f480a-9918-4cea-819c-62e5c7f2b332")]
		public void GetCollaborateurByReferent_ReferentNotFound(Guid idReferent)
		{
			ICollaborateurService collaborateurService = new CollaborateurService(collaborateurApi, context, transformDTO);

			AsyncTestDelegate exception = () => collaborateurService.GetCollaborateursByReferentAsync(idReferent, true, 1, 15, "", "");
			Assert.ThrowsAsync(typeof(ReferentNotFoundException), exception);
		}



		#endregion

		#region GetCollaborateurs by guids
		
		[Test]
		public async Task GetCollaborateurByGuids()
		{
			ICollaborateurService collaborateurService = new CollaborateurService(collaborateurApi, context, transformDTO);

			List<Guid?> guids = new List<Guid?>();
			guids.Add(new Guid("ebd911ef-a6a8-4047-afdc-9a9066aa1a07"));
			guids.Add(new Guid("71d33f6d-695a-4dc6-ae1a-b1605fd2073d"));
			guids.Add(new Guid("56e3d82d-4be4-4449-a1f7-b4004b6bd186"));
			guids.Add(new Guid("a43b6f4f-f199-4dd0-93b6-a1cb2c0a0d14"));
			guids.Add(new Guid("a0f40e2a-cc03-4032-a627-5389e1281c64"));
			guids.Add(new Guid("a29d707c-5d82-4c48-bed1-a6d1c1710047"));
			IEnumerable<CollaborateurDTO> collaborateurs = await collaborateurService.GetCollaborateurDTOsAsync(guids);
			foreach(CollaborateurDTO c in collaborateurs)
			{
				Assert.IsTrue(guids.Contains(c.Id));
			}
			Assert.AreEqual(guids.Count, collaborateurs.Count());
		}

		[Test]
		public async Task GetCollaborateurByGuidsAvecIdsNonExistantEnPlus()
		{
			ICollaborateurService collaborateurService = new CollaborateurService(collaborateurApi, context, transformDTO);

			List<Guid?> guids = new List<Guid?>();
			guids.Add(new Guid("b645f582-0a5d-48dc-97a1-4ebb0fb3a29f"));
			guids.Add(new Guid());
			guids.Add(new Guid("f42f65cb-dcc1-407f-a048-f67efbe88d65"));
			guids.Add(new Guid("e634de52-d921-4ae8-954d-215f39712041"));
			guids.Add(new Guid("ad63ff07-6dae-4b02-8d49-1cacf1e8a224"));
			guids.Add(new Guid("25d2b0ce-5c95-4ccc-98bb-63b06c4ee4ad"));
			guids.Add(new Guid());
			IEnumerable<CollaborateurDTO> collaborateurs = await collaborateurService.GetCollaborateurDTOsAsync(guids);
			foreach (CollaborateurDTO c in collaborateurs)
			{
				Assert.IsTrue(guids.Contains(c.Id));
			}
			Assert.AreEqual(guids.Count, collaborateurs.Count()+2);
		}

		[Test]
		public async Task GetCollaborateurByGuidsAvecIdsNonExistantUniquement()
		{
			ICollaborateurService collaborateurService = new CollaborateurService(collaborateurApi, context, transformDTO);

			List<Guid?> guids = new List<Guid?>();
			guids.Add(new Guid());
			guids.Add(new Guid());
			guids.Add(new Guid());
			guids.Add(new Guid());
			guids.Add(new Guid());
			guids.Add(new Guid());
			IEnumerable<CollaborateurDTO> collaborateurs = await collaborateurService.GetCollaborateurDTOsAsync(guids);
			Assert.AreNotEqual(guids.Count, collaborateurs.Count());
			Assert.AreEqual(0, collaborateurs.Count());
		}
		#endregion

	}
}