Digitalisation_EPA_Serveur/EPAServeur.Tests/Services/EpInformationTests.cs

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

namespace EPAServeur.Tests.Services
{
	[TestFixture]
	public class EpInformationTests
	{
		#region
		private EpContext context;
		private ICollaborateurService collaborateurService;

		#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.AddEp(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;
			}
			collaborateurService = new CollaborateurService(new CollaborateurApi(), context);
		}
		#endregion

		#region Récupération des EP en cours

		[TestCase(1, 3)] //Tours
		[TestCase(2, 3)] //Orléans
		[TestCase(3, 3)] // Paris
		public async Task GetEpEnCours_UneBU(long? idBUs, int nbElements)
		{
			IEpInformationService epInformationService = new EpInformationService(context, collaborateurService);

			IEnumerable<EpInformationDTO> epInformationDTOs = await epInformationService.GetEPEnCours(new List<long?>{ idBUs }, true, 1, 15, "", "", null, null);
			int count = await epInformationService.GetEPEnCoursCount(new List<long?> { idBUs }, true, 1, 15, "", "", null, null);
			Assert.AreEqual(count, nbElements);
			Assert.AreEqual(count, epInformationDTOs.Count());
			foreach(EpInformationDTO ep in epInformationDTOs)
			{
				Assert.AreEqual(ep.Collaborateur.BusinessUnit.Id, idBUs);
				Assert.IsTrue(EstEpEnCours(ep.Statut));
			}
		}

		
		public async Task GetEpEnCours_OrleansTours()
		{
			IEpInformationService epInformationService = new EpInformationService(context, collaborateurService);

			IEnumerable<EpInformationDTO> epInformationDTOs = await epInformationService.GetEPEnCours(new List<long?> { 1,2 }, true, 1, 15, "", "", null, null);
			int count = await epInformationService.GetEPEnCoursCount(new List<long?> { 1, 2 }, true, 1, 15, "", "", null, null);
			Assert.AreEqual(count, 8);
			Assert.AreEqual(count, epInformationDTOs.Count());
			long? bu;
			foreach(EpInformationDTO ep in epInformationDTOs)
			{
				bu = ep.Collaborateur.BusinessUnit.Id;
				Assert.IsTrue(bu == 1 || bu == 2);
				Assert.IsTrue(EstEpEnCours(ep.Statut));
			}
		}

		//tri colonne
		[TestCase("agence")]
		[TestCase("collaborateur")]
		[TestCase("referent")]
		[TestCase("date")]
		[TestCase("typeep")]
		[TestCase("etatep")]
		public async Task GetEpEnCours_TriColonneASC(string tri)
		{
			IEpInformationService epInformationService = new EpInformationService(context, collaborateurService);
			IEnumerable<EpInformationDTO> epInformationDTOs = await epInformationService.GetEPEnCours(new List<long?> { 1, 2 }, true, 1, 15, "", tri, null, null);
			EpInformationDTO ep1, ep2;
			int compare = 0;
			for(int i = 0; i < epInformationDTOs.Count()-1; ++i)
			{
				ep1 = epInformationDTOs.ElementAt(i);
				ep2 = epInformationDTOs.ElementAt(i+1);
				switch(tri)
				{
					case "agence":
						compare = ep1.Collaborateur.BusinessUnit.Nom.CompareTo(ep2.Collaborateur.BusinessUnit.Nom);
						break;
					case "collaborateur":
						compare = (ep1.Collaborateur.Nom + " " + ep1.Collaborateur.Prenom).CompareTo((ep2.Collaborateur.Nom + " " + ep2.Collaborateur.Prenom));
						break;
					case "referent":
						compare = (ep1.Referent.Nom + " " + ep1.Referent.Prenom).CompareTo((ep2.Referent.Nom + " " + ep2.Referent.Prenom));
						break;
					case "date":
						compare = ep1.DatePrevisionnelle.Value.CompareTo(ep2.DatePrevisionnelle.Value);
						break;
					case "typeep":
						compare = ep1.Type.CompareTo(ep2.Type);
						break;
					case "etatep":
						compare = ep1.Statut.CompareTo(ep2.Statut);
						break;
				}
				Assert.IsTrue(compare <= 0);
				Assert.IsTrue(EstEpEnCours(ep1.Statut));
				Assert.IsTrue(EstEpEnCours(ep2.Statut));
			}
		}


		//tri colonne
		[TestCase("agence")]
		[TestCase("collaborateur")]
		[TestCase("referent")]
		[TestCase("date")]
		[TestCase("typeep")]
		[TestCase("etatep")]
		public async Task GetEpEnCours_TriColonneDESC(string tri)
		{
			IEpInformationService epInformationService = new EpInformationService(context, collaborateurService);
			IEnumerable<EpInformationDTO> epInformationDTOs = await epInformationService.GetEPEnCours(new List<long?> { 1, 2 }, false, 1, 15, "", tri, null, null);
			EpInformationDTO ep1, ep2;
			int compare = 0;
			for (int i = 0; i < epInformationDTOs.Count() - 1; ++i)
			{
				ep1 = epInformationDTOs.ElementAt(i);
				ep2 = epInformationDTOs.ElementAt(i + 1);
				switch (tri)
				{
					case "agence":
						compare = ep1.Collaborateur.BusinessUnit.Nom.CompareTo(ep2.Collaborateur.BusinessUnit.Nom);
						break;
					case "collaborateur":
						compare = (ep1.Collaborateur.Nom + " " + ep1.Collaborateur.Prenom).CompareTo(ep2.Collaborateur.Nom + " " + ep2.Collaborateur.Prenom);
						break;
					case "referent":
						compare = (ep1.Referent.Nom + " " + ep1.Referent.Prenom).CompareTo((ep2.Referent.Nom + " " + ep2.Referent.Prenom));
						break;
					case "date":
						compare = ep1.DatePrevisionnelle.Value.CompareTo(ep2.DatePrevisionnelle.Value);
						break;
					case "typeep":
						compare = ep1.Type.CompareTo(ep2.Type);
						break;
					case "etatep":
						compare = ep1.Statut.CompareTo(ep2.Statut);
						break;
				}
				Assert.IsTrue(compare >= 0);
				Assert.IsTrue(EstEpEnCours(ep1.Statut));
				Assert.IsTrue(EstEpEnCours(ep2.Statut));
			}
		}

		//tris date
		[TestCase(01, 03, 2021, 5)]	
		[TestCase(20, 03, 2021, 2)]	
		[TestCase(01, 04, 2021, 0)]	
		public async Task GetEpEnCours_TriDateD1(int j, int m, int a, int count)
		{
			DateTime date = new DateTime(a, m, j);
			IEpInformationService epInformationService = new EpInformationService(context, collaborateurService);

			IEnumerable<EpInformationDTO> epInformationDTOs = await epInformationService.GetEPEnCours(new List<long?> { 1, 2 }, true, 1, 15, "", "", date, null);
			Assert.AreEqual(epInformationDTOs.Count(), count);
			foreach(EpInformationDTO ep in epInformationDTOs)
			{
				Assert.IsTrue(date <= ep.DatePrevisionnelle.Value);
				Assert.IsTrue(EstEpEnCours(ep.Statut));
			}
		}

		[TestCase(01, 04, 2021, 6)]
		[TestCase(15, 03, 2021, 3)]
		[TestCase(1, 02, 2021, 0)]
		public async Task GetEpEnCours_TriDateD2(int j, int m, int a, int count)
		{
			DateTime date = new DateTime(a, m, j); IEpInformationService epInformationService = new EpInformationService(context, collaborateurService);

			IEnumerable<EpInformationDTO> epInformationDTOs = await epInformationService.GetEPEnCours(new List<long?> { 1, 2 }, true, 1, 15, "", "", null, date);
			Assert.AreEqual(epInformationDTOs.Count(), count);
			foreach (EpInformationDTO ep in epInformationDTOs)
			{
				Assert.IsTrue(date >= ep.DatePrevisionnelle.Value);
				Assert.IsTrue(EstEpEnCours(ep.Statut));
			}
		}

		[TestCase(01, 02, 2021, 28, 02, 2021, 1)]
		[TestCase(01, 02, 2021, 01, 04, 2021, 6)]
		[TestCase(15, 02, 2021, 15, 03, 2021, 3)]
		[TestCase(01, 01, 2021, 31, 01, 2021, 0)]
		[TestCase(01, 01, 2022, 31, 01, 2022, 0)]
		public async Task GetEpEnCours_TriDateD1D2(int j1, int m1, int a1, int j2, int m2, int a2, int count)
		{
			DateTime date1 = new DateTime(a1, m1, j1);
			DateTime date2 = new DateTime(a2, m2, j2);
			IEpInformationService epInformationService = new EpInformationService(context, collaborateurService);

			IEnumerable<EpInformationDTO> epInformationDTOs = await epInformationService.GetEPEnCours(new List<long?> { 1, 2 }, true, 1, 15, "", "", date1, date2);
			Assert.AreEqual(epInformationDTOs.Count(), count);
			foreach (EpInformationDTO ep in epInformationDTOs)
			{
				Assert.IsTrue(condition: date1 <= ep.DatePrevisionnelle.Value);
				Assert.IsTrue(date2 >= ep.DatePrevisionnelle.Value);
				Assert.IsTrue(EstEpEnCours(ep.Statut));
			}
		}

		//Tri texte
		[TestCase("", 6)]
		[TestCase("Ma", 2)]
		[TestCase("Ne", 2)]
		[TestCase("nE", 2)]
		[TestCase("ma", 2)]
		[TestCase("D", 2)]
		[TestCase("d", 2)]
		public async Task GetEpEnCours_texte(string texte, int count)
		{
			IEpInformationService epInformationService = new EpInformationService(context, collaborateurService);
			IEnumerable<EpInformationDTO> epInformationDTOs = await epInformationService.GetEPEnCours(new List<long?> { 1, 2 }, true, 1, 15, texte, "", null, null);
			Assert.AreEqual(count, epInformationDTOs.Count());
			foreach (EpInformationDTO ep in epInformationDTOs)
			{
				Assert.IsTrue((ep.Collaborateur.Nom + " " + ep.Collaborateur.Prenom).ToLower().Contains(texte.ToLower()) || (ep.Collaborateur.Prenom + " " + ep.Collaborateur.Nom).ToLower().Contains(texte.ToLower()));
				Assert.IsTrue(EstEpEnCours(ep.Statut));
			}

		}

		#endregion


		#region Récupération des EP signés
		[TestCase(1, 3)] //Tours
		[TestCase(2, 3)] //Orléans
		[TestCase(3, 3)] // Paris
		public async Task GetEpSignes_UneBU(long? idBUs, int nbElements)
		{
			IEpInformationService epInformationService = new EpInformationService(context, collaborateurService);

			IEnumerable<EpInformationDTO> epInformationDTOs = await epInformationService.GetEPSignes(new List<long?>{ idBUs }, true, 1, 15, "", "", null, null);
			int count = await epInformationService.GetEPSignesCount(new List<long?> { idBUs }, true, 1, 15, "", "", null, null);
			Assert.AreEqual(count, nbElements);
			Assert.AreEqual(count, epInformationDTOs.Count());
			foreach(EpInformationDTO ep in epInformationDTOs)
			{
				Assert.AreEqual(ep.Collaborateur.BusinessUnit.Id, idBUs);
				Assert.IsTrue(ep.Statut == StatutEp.Signe);
			}
		}

		
		public async Task GetEpSignes_OrleansTours()
		{
			IEpInformationService epInformationService = new EpInformationService(context, collaborateurService);

			IEnumerable<EpInformationDTO> epInformationDTOs = await epInformationService.GetEPSignes(new List<long?> { 1,2 }, true, 1, 15, "", "", null, null);
			int count = await epInformationService.GetEPSignesCount(new List<long?> { 1, 2 }, true, 1, 15, "", "", null, null);
			Assert.AreEqual(count, 8);
			Assert.AreEqual(count, epInformationDTOs.Count());
			long? bu;
			foreach(EpInformationDTO ep in epInformationDTOs)
			{
				bu = ep.Collaborateur.BusinessUnit.Id;
				Assert.IsTrue(bu == 1 || bu == 2);
				Assert.IsTrue(ep.Statut == StatutEp.Signe);
			}
		}

		//tri colonne
		[TestCase("agence")]
		[TestCase("collaborateur")]
		[TestCase("referent")]
		[TestCase("date")]
		[TestCase("typeep")]
		public async Task GetEpSignes_TriColonneASC(string tri)
		{
			IEpInformationService epInformationService = new EpInformationService(context, collaborateurService);
			IEnumerable<EpInformationDTO> epInformationDTOs = await epInformationService.GetEPSignes(new List<long?> { 1, 2 }, true, 1, 15, "", tri, null, null);
			EpInformationDTO ep1, ep2;
			int compare = 0;
			for(int i = 0; i < epInformationDTOs.Count()-1; ++i)
			{
				ep1 = epInformationDTOs.ElementAt(i);
				ep2 = epInformationDTOs.ElementAt(i+1);
				switch(tri)
				{
					case "agence":
						compare = ep1.Collaborateur.BusinessUnit.Nom.CompareTo(ep2.Collaborateur.BusinessUnit.Nom);
						break;
					case "collaborateur":
						compare = (ep1.Collaborateur.Nom + " " + ep1.Collaborateur.Prenom).CompareTo((ep2.Collaborateur.Nom + " " + ep2.Collaborateur.Prenom));
						break;
					case "referent":
						compare = (ep1.Referent.Nom + " " + ep1.Referent.Prenom).CompareTo((ep2.Referent.Nom + " " + ep2.Referent.Prenom));
						break;
					case "date":
						compare = ep1.DatePrevisionnelle.Value.CompareTo(ep2.DatePrevisionnelle.Value);
						break;
					case "typeep":
						compare = ep1.Type.CompareTo(ep2.Type);
						break;
				}
				Assert.IsTrue(compare <= 0);

				Assert.IsTrue(ep1.Statut == StatutEp.Signe);
				Assert.IsTrue(ep2.Statut == StatutEp.Signe);
			}
		}


		//tri colonne
		[TestCase("agence")]
		[TestCase("collaborateur")]
		[TestCase("referent")]
		[TestCase("date")]
		[TestCase("typeep")]
		public async Task GetEpSignes_TriColonneDESC(string tri)
		{
			IEpInformationService epInformationService = new EpInformationService(context, collaborateurService);
			IEnumerable<EpInformationDTO> epInformationDTOs = await epInformationService.GetEPSignes(new List<long?> { 1, 2 }, false, 1, 15, "", tri, null, null);
			EpInformationDTO ep1, ep2;
			int compare = 0;
			for (int i = 0; i < epInformationDTOs.Count() - 1; ++i)
			{
				ep1 = epInformationDTOs.ElementAt(i);
				ep2 = epInformationDTOs.ElementAt(i + 1);
				switch (tri)
				{
					case "agence":
						compare = ep1.Collaborateur.BusinessUnit.Nom.CompareTo(ep2.Collaborateur.BusinessUnit.Nom);
						break;
					case "collaborateur":
						compare = (ep1.Collaborateur.Nom + " " + ep1.Collaborateur.Prenom).CompareTo(ep2.Collaborateur.Nom + " " + ep2.Collaborateur.Prenom);
						break;
					case "referent":
						compare = (ep1.Referent.Nom + " " + ep1.Referent.Prenom).CompareTo((ep2.Referent.Nom + " " + ep2.Referent.Prenom));
						break;
					case "date":
						compare = ep1.DatePrevisionnelle.Value.CompareTo(ep2.DatePrevisionnelle.Value);
						break;
					case "typeep":
						compare = ep1.Type.CompareTo(ep2.Type);
						break;
					case "etatep":
						compare = ep1.Statut.CompareTo(ep2.Statut);
						break;
				}
				Assert.IsTrue(compare >= 0);

				Assert.IsTrue(ep1.Statut == StatutEp.Signe);
				Assert.IsTrue(ep2.Statut == StatutEp.Signe);
			}
		}

		//tris date
		[TestCase(01, 01, 2018, 4)]
		[TestCase(01, 01, 2019, 2)]
		[TestCase(01, 01, 2020, 1)]
		[TestCase(01, 01, 2021, 0)]
		[TestCase(01, 01, 2022, 0)]
		public async Task GetEpSignes_TriDateD1(int j, int m, int a, int count)
		{
			DateTime date = new DateTime(a, m, j);
			IEpInformationService epInformationService = new EpInformationService(context, collaborateurService);

			IEnumerable<EpInformationDTO> epInformationDTOs = await epInformationService.GetEPSignes(new List<long?> { 1, 2 }, true, 1, 15, "", "", date, null);
			Assert.AreEqual(epInformationDTOs.Count(), count);
			foreach(EpInformationDTO ep in epInformationDTOs)
			{
				Assert.IsTrue(date <= ep.DatePrevisionnelle.Value);
				Assert.IsTrue(ep.Statut == StatutEp.Signe);
			}
		}

		[TestCase(31, 12, 2019)]
		[TestCase(01, 01, 2019)]
		[TestCase(31, 07, 2018)]
		[TestCase(31, 07, 2017)]
		public async Task GetEpSignes_TriDateD2(int j, int m, int a)
		{
			DateTime date = new DateTime(a, m, j); IEpInformationService epInformationService = new EpInformationService(context, collaborateurService);

			IEnumerable<EpInformationDTO> epInformationDTOs = await epInformationService.GetEPSignes(new List<long?> { 1, 2 }, true, 1, 15, "", "", null, date);
			int count = await epInformationService.GetEPSignesCount(new List<long?> { 1, 2 }, true, 1, 15, "", "", null, date);
			Assert.AreEqual(epInformationDTOs.Count(), count);
			foreach (EpInformationDTO ep in epInformationDTOs)
			{
				Assert.IsTrue(date >= ep.DatePrevisionnelle.Value);
				Assert.IsTrue(ep.Statut == StatutEp.Signe);
			}
		}

		[TestCase(01, 07, 2021, 31, 12, 2021, 0)]
		[TestCase(01, 09, 2018, 01, 12, 2019, 1)]
		[TestCase(01, 01, 2018, 31, 12, 2019, 3)]
		[TestCase(01, 01, 2017, 31, 12, 2017, 2)]
		public async Task GetEpSignes_TriDateD1D2(int j1, int m1, int a1, int j2, int m2, int a2, int count)
		{
			DateTime date1 = new DateTime(a1, m1, j1);
			DateTime date2 = new DateTime(a2, m2, j2);
			IEpInformationService epInformationService = new EpInformationService(context, collaborateurService);

			IEnumerable<EpInformationDTO> epInformationDTOs = await epInformationService.GetEPSignes(new List<long?> { 1, 2 }, true, 1, 15, "", "", date1, date2);
			Assert.AreEqual(epInformationDTOs.Count(), count);
			foreach (EpInformationDTO ep in epInformationDTOs)
			{
				Assert.IsTrue(condition: date1 <= ep.DatePrevisionnelle.Value);
				Assert.IsTrue(date2 >= ep.DatePrevisionnelle.Value);
				Assert.IsTrue(ep.Statut == StatutEp.Signe);
			}
		}

		//Tri texte
		[TestCase("", 6)]
		[TestCase("Ma", 2)]
		[TestCase("Ne", 2)]
		[TestCase("nE", 2)]
		[TestCase("ma",2)]
		[TestCase("D", 2)]
		[TestCase("d", 2)]
		public async Task GetEpSignes_texte(string texte, int count)
		{
			IEpInformationService epInformationService = new EpInformationService(context, collaborateurService);
			IEnumerable<EpInformationDTO> epInformationDTOs = await epInformationService.GetEPSignes(new List<long?> { 1, 2 }, true, 1, 15, texte, "", null, null);
			Assert.AreEqual(count, epInformationDTOs.Count());
			foreach (EpInformationDTO ep in epInformationDTOs)
			{
				Assert.IsTrue((ep.Collaborateur.Nom + " " + ep.Collaborateur.Prenom).ToLower().Contains(texte.ToLower()) || (ep.Collaborateur.Prenom + " " + ep.Collaborateur.Nom).ToLower().Contains(texte.ToLower()));
				Assert.IsTrue(ep.Statut == StatutEp.Signe);
			}
		}

		#endregion

		#region méthodes privées 
		private bool EstEpEnCours(StatutEp statut)
		{
			return statut != StatutEp.Annule && statut != StatutEp.Cree && statut != StatutEp.Rejete && statut != StatutEp.Signe;
		}
		#endregion
	}
}