Digitalisation_EPA_Serveur/EPAServeur.Tests/Services/NoteServiceTests.cs

using EPAServeur.Context;
using EPAServeur.Exceptions;
using EPAServeur.IServices;
using EPAServeur.Models.Notes;
using EPAServeur.Services;
using IO.Swagger.ApiCollaborateur;
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 NoteServiceTests
	{
		#region Variables
		private EpContext context;
		private ICollaborateurApi collaborateurApi;
		private ICollaborateurService collaborateurService;
		private Guid? auteur1, auteur2, auteur3;
		private Guid? collaborateur1, collaborateur2, collaborateur3;
		private Guid? auteurNonExistant, collaborateurNonExistant, collaborateurParti, referentParti;
		#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.AddNotes(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;
			}
			collaborateurApi = new CollaborateurApi();
			collaborateurService = new CollaborateurService(collaborateurApi, context);


			auteur1 = new Guid("aa36f34c-9041-42f5-9db3-6536fe7f1696");
			auteur2 = new Guid("01ee85ff-d7f3-494b-b1de-26ced8fbfa0d");
			auteur3 = new Guid("eb8b0f33-f529-4985-861e-1207f3312bb5");

			collaborateur1 = new Guid("842650db-a548-4472-a3af-4c5fff3c1ab8");
			collaborateur2 = new Guid("b5254c6c-7caa-435f-a4bb-e0cf92559832");
			collaborateur3 = new Guid("de98a866-736f-4295-a669-92a8694e2ee3");

			auteurNonExistant = collaborateurNonExistant = new Guid("397f616e-44ff-11eb-b378-0242ac130002");
			collaborateurParti = new Guid("13fbe621-1bc9-4f04-afde-b54ca076e239");
			referentParti = new Guid("ea027734-ff0f-4308-8879-133a09fb3c46");

		}
		#endregion


		#region Test AjouterNote
		[Test]
		public async Task AjouterNote_Ajouter4NoteAvecSucces()
		{
			

			// récupérer les collaborateurs liés aux notes
			CollaborateurDTO collaborateur1DTO = await collaborateurService.GetCollaborateurByIdAsync(collaborateur1);
			CollaborateurDTO collaborateur2DTO = await collaborateurService.GetCollaborateurByIdAsync(collaborateur2);
			CollaborateurDTO collaborateur3DTO = await collaborateurService.GetCollaborateurByIdAsync(collaborateur3);

			INoteService noteService = new NoteService(collaborateurApi, collaborateurService, context);
			DateTime date = DateTime.Now;
			
			DetailsNoteDTO noteAjoutee1, noteAjoutee2;
			Note noteAjoutee3, noteAjoutee4;

			DetailsNoteDTO nouvelleNote1 = new DetailsNoteDTO()
			{
				Collaborateur = collaborateur1DTO,
				DateCreation = date,
				DateMiseAjour = date,
				IdAuteur = auteur1,
				Texte = "Texte nouvelle note 11",
				Titre = "Titre nouvelle note 11"
			};

			noteAjoutee1 = await noteService.AjouterNoteAsync(nouvelleNote1);
			
			DetailsNoteDTO nouvelleNote2 = new DetailsNoteDTO()
			{
				Collaborateur = collaborateur2DTO,
				DateCreation = date,
				DateMiseAjour = date,
				IdAuteur = auteur2,
				Texte = "Texte nouvelle note 12",
				Titre = "Titre nouvelle note 12"
			};
			
			noteAjoutee2 = await noteService.AjouterNoteAsync(nouvelleNote2);
			
			DetailsNoteDTO nouvelleNote3 = new DetailsNoteDTO()
			{
				Collaborateur = collaborateur3DTO,
				DateCreation = date,
				DateMiseAjour = date,
				IdAuteur = auteur3,
				Texte = "Texte nouvelle note 13",
				Titre = "Titre nouvelle note 13",
			};

			await noteService.AjouterNoteAsync(nouvelleNote3);
			noteAjoutee3 = await context.Note.FindAsync((long)13);

			DetailsNoteDTO nouvelleNote4 = new DetailsNoteDTO()
			{
				Collaborateur = collaborateur3DTO,
				DateCreation = date,
				DateMiseAjour = date,
				IdAuteur = auteur1,
				Texte = "Texte nouvelle note 14",
				Titre = "Titre nouvelle note 14"
			};

			await noteService.AjouterNoteAsync(nouvelleNote4);
			noteAjoutee4 = await context.Note.FindAsync((long)14);
			

			//Assert note 1
			Assert.IsNotNull(noteAjoutee1);
			Assert.AreEqual(11, noteAjoutee1.Id);
			Assert.AreEqual(nouvelleNote1.IdAuteur, noteAjoutee1.IdAuteur);
			Assert.AreEqual(nouvelleNote1.DateCreation, noteAjoutee1.DateCreation);
			Assert.AreEqual(nouvelleNote1.Collaborateur.Id, noteAjoutee1.Collaborateur.Id);
			Assert.AreEqual(nouvelleNote1.Titre, noteAjoutee1.Titre);
			Assert.AreEqual(nouvelleNote1.Texte, noteAjoutee1.Texte);
			Assert.AreEqual(nouvelleNote1.DateMiseAjour, noteAjoutee1.DateMiseAjour);
			Assert.AreEqual(nouvelleNote1.DateCreation, noteAjoutee1.DateCreation);



			//Assert note 2
			Assert.IsNotNull(noteAjoutee2);
			Assert.AreEqual(12, noteAjoutee2.Id);
			Assert.AreEqual(nouvelleNote2.IdAuteur, noteAjoutee2.IdAuteur);
			Assert.AreEqual(nouvelleNote2.DateCreation, noteAjoutee2.DateCreation);
			Assert.AreEqual(nouvelleNote2.Collaborateur.Id, noteAjoutee2.Collaborateur.Id);
			Assert.AreEqual(nouvelleNote2.Titre, noteAjoutee2.Titre);
			Assert.AreEqual(nouvelleNote2.Texte, noteAjoutee2.Texte);
			Assert.AreEqual(nouvelleNote2.DateMiseAjour, noteAjoutee2.DateMiseAjour);
			Assert.AreEqual(nouvelleNote2.DateCreation, noteAjoutee2.DateCreation);

			
			//Assert note 3
			Assert.IsNotNull(noteAjoutee3);
			Assert.AreEqual(13, noteAjoutee3.IdNote);
			Assert.AreEqual(nouvelleNote3.IdAuteur, noteAjoutee3.IdAuteur);
			Assert.AreEqual(nouvelleNote3.DateCreation, noteAjoutee3.DateCreation);
			Assert.AreEqual(nouvelleNote3.Collaborateur.Id, noteAjoutee3.IdCollaborateur);
			Assert.AreEqual(nouvelleNote3.Titre, noteAjoutee3.Titre);
			Assert.AreEqual(nouvelleNote3.Texte, noteAjoutee3.Texte);
			Assert.AreEqual(nouvelleNote3.DateMiseAjour, noteAjoutee3.DateMiseAJour);
			Assert.AreEqual(nouvelleNote3.DateCreation, noteAjoutee3.DateCreation);



			//Assert note 4
			Assert.IsNotNull(noteAjoutee4);
			Assert.AreEqual(14, noteAjoutee4.IdNote);
			Assert.AreEqual(nouvelleNote4.IdAuteur, noteAjoutee4.IdAuteur);
			Assert.AreEqual(nouvelleNote4.DateCreation, noteAjoutee4.DateCreation);
			Assert.AreEqual(nouvelleNote4.Collaborateur.Id, noteAjoutee4.IdCollaborateur);
			Assert.AreEqual(nouvelleNote4.Titre, noteAjoutee4.Titre);
			Assert.AreEqual(nouvelleNote4.Texte, noteAjoutee4.Texte);
			Assert.AreEqual(nouvelleNote4.DateMiseAjour, noteAjoutee4.DateMiseAJour);
			Assert.AreEqual(nouvelleNote4.DateCreation, noteAjoutee4.DateCreation);
			

		}


		[TestCase("", "")]
		[TestCase("Titre 2", "")]
		[TestCase("", "Texte 3")]
		[TestCase("Titre 3", "Te")]
		[TestCase("T", "Texte 4")]
		[TestCase("T", "T")]
		public async Task AjouterNote_NoteInvalideException(string titre, string texte)
		{


			CollaborateurDTO collaborateurDTO = await collaborateurService.GetCollaborateurByIdAsync(collaborateur1);

			INoteService noteService = new NoteService(collaborateurApi, collaborateurService, context);
			DateTime date = DateTime.Now;

			DetailsNoteDTO noteAjoutee1 = new DetailsNoteDTO()
			{
				Collaborateur = collaborateurDTO,
				DateCreation  = date,
				DateMiseAjour = date,
				IdAuteur = auteur1,
				Texte = texte,
				Titre = titre,
			};

			AsyncTestDelegate exception = () => noteService.AjouterNoteAsync(noteAjoutee1);

			Assert.ThrowsAsync(typeof(NoteInvalideException), exception);
		}
		
		[Test]
		public async Task AjouterNote_ReferentNotFoundException()
		{
			CollaborateurDTO collaborateurDTO = await collaborateurService.GetCollaborateurByIdAsync(collaborateur1);

			INoteService noteService = new NoteService(collaborateurApi, collaborateurService, context);
			DateTime date = DateTime.Now;

			DetailsNoteDTO note = new DetailsNoteDTO()
			{
				Collaborateur = collaborateurDTO,
				DateCreation = date,
				DateMiseAjour = date,
				IdAuteur = auteurNonExistant,
				Texte = "Texte nouvelle note",
				Titre = "Titre nouvelle note"
			};

			AsyncTestDelegate exception = () => noteService.AjouterNoteAsync(note);
			Assert.ThrowsAsync(typeof(ReferentNotFoundException), exception);
		}
		
		[Test]
		public async Task AjouterNote_CollaborateurNotFoundException()
		{
			CollaborateurDTO collaborateurDTO = await collaborateurService.GetCollaborateurByIdAsync(collaborateur1);
			collaborateurDTO.Id = collaborateurNonExistant;

			INoteService noteService = new NoteService(collaborateurApi, collaborateurService, context);
			DateTime date = DateTime.Now;

			DetailsNoteDTO note = new DetailsNoteDTO()
			{
				Collaborateur = collaborateurDTO,
				DateCreation = date,
				DateMiseAjour = date,
				IdAuteur = auteur1,
				Texte = "Texte nouvelle note",
				Titre = "Titre nouvelle note"
			};

			AsyncTestDelegate exception = () => noteService.AjouterNoteAsync(note);
			Assert.ThrowsAsync(typeof(CollaborateurNotFoundException), exception);
		}

		
		//[Test]
		[Test]
		public async Task AjouterNote_CollaborateurPartiException()
		{
			CollaborateurDTO collaborateurDTO = await collaborateurService.GetCollaborateurByIdAsync(collaborateur1);
			CollaborateurDTO collaborateurPartiDTO = await collaborateurService.GetCollaborateurByIdAsync(collaborateurParti);

			INoteService noteService = new NoteService(collaborateurApi, collaborateurService, context);
			DateTime date = DateTime.Now;


			DetailsNoteDTO note1 = new DetailsNoteDTO()
			{
				Collaborateur = collaborateurDTO,
				DateCreation = date,
				DateMiseAjour = date,
				IdAuteur = referentParti,
				Texte = "Texte note 1",
				Titre = "Titre note 1"
			};

			AsyncTestDelegate exception1 = () =>  noteService.AjouterNoteAsync(note1);
			
			DetailsNoteDTO note2 = new DetailsNoteDTO()
			{
				Collaborateur = collaborateurPartiDTO,
				DateCreation = date,
				DateMiseAjour = date,
				IdAuteur = auteur2,
				Texte = "Texte note 2",
				Titre = "Titre note 2"
			};

			AsyncTestDelegate exception2 = () => noteService.AjouterNoteAsync(note2);

			Assert.ThrowsAsync(typeof(CollaborateurPartiException), exception1);
			Assert.ThrowsAsync(typeof(CollaborateurPartiException), exception2);
		}
		
		#endregion

		#region Tests GetNoteById
		[TestCase(1)]
		[TestCase(2)]
		[TestCase(4)]
		[TestCase(5)]
		[TestCase(6)]
		[TestCase(9)]
		public async Task GetNote_NoteNotNull(long id)
		{
			INoteService noteService = new NoteService(collaborateurApi, collaborateurService, context);
			DetailsNoteDTO detailsNoteDTO = await noteService.GetNoteByIdAsync(id);

			Assert.NotNull(detailsNoteDTO);
			Assert.NotNull(detailsNoteDTO.Titre);
			Assert.NotNull(detailsNoteDTO.Texte);
			Assert.NotNull(detailsNoteDTO.IdAuteur);
			Assert.NotNull(detailsNoteDTO.Collaborateur);
			Assert.NotNull(detailsNoteDTO.DateCreation);
			Assert.NotNull(detailsNoteDTO.DateMiseAjour);
			Assert.AreEqual(id, detailsNoteDTO.Id);

		}


		[TestCase(-999)]
		[TestCase(-1)]
		[TestCase(0)]
		[TestCase(11)]
		[TestCase(20)]
		[TestCase(30)]
		[TestCase(100)]
		public void GetNote_NoteNotFoundException(long id)
		{
			INoteService noteService = new NoteService(collaborateurApi, collaborateurService, context);
			AsyncTestDelegate exception = () => noteService.GetNoteByIdAsync(id);
			Assert.ThrowsAsync(typeof(NoteNotFoundException), exception);
		}

		[TestCase(3)]
		[TestCase(7)]
		public void GetNote_ReferentNotFoundException(long id)
		{
			INoteService noteService = new NoteService(collaborateurApi, collaborateurService, context);
			AsyncTestDelegate exception = () => noteService.GetNoteByIdAsync(id);
			Assert.ThrowsAsync(typeof(ReferentNotFoundException), exception);
		}

		[TestCase(8)]
		[TestCase(10)]
		public void GetNote_CollaborateurNotFoundException(long id)
		{
			INoteService noteService = new NoteService(collaborateurApi, collaborateurService, context);
			AsyncTestDelegate exception = () => noteService.GetNoteByIdAsync(id);
			Assert.ThrowsAsync(typeof(CollaborateurNotFoundException), exception);
		}



		#endregion


		#region Test Supprimer Note
		[TestCase(5)]
		[TestCase(7)]
		[TestCase(8)]
		public async Task SupprimerNote_Succes(long id)
		{
			INoteService noteService = new NoteService(collaborateurApi, collaborateurService, context);
			await noteService.SupprimerNoteAsync(id);

			Note note = await context.Note.FindAsync(id);

			Assert.IsNull(note);
		}



		[TestCase(0)]
		[TestCase(-1)]
		[TestCase(-999)]
		[TestCase(20)]
		[TestCase(30)]
		[TestCase(100)]
		public void SupprimerNote_NoteNotFoundException(long id)
		{
			INoteService noteService = new NoteService(collaborateurApi, collaborateurService, context);
			AsyncTestDelegate exception = () => noteService.SupprimerNoteAsync(id);
			Assert.ThrowsAsync(typeof(NoteNotFoundException), exception);

		}

		#endregion


		#region Tests UpdateNote

		[TestCase(1)]
		[TestCase(2)]
		[TestCase(6)]
		[TestCase(9)]
		public async Task UpdateNote_UpdateTitreEtTexte(long id)
		{
			INoteService noteService = new NoteService(collaborateurApi, collaborateurService, context);
			DetailsNoteDTO note = await noteService.GetNoteByIdAsync(id);
			note.Titre = "Titre à jour " + id;
			note.Texte= "Texte à jour " + id;
			DetailsNoteDTO noteUpdate = await noteService.UpdateNoteAsync(id, note);
			Note noteUpdated = context.Note.Find(noteUpdate.Id);
			Assert.IsNotNull(noteUpdate);
			Assert.IsNotNull(noteUpdated);
			Assert.AreEqual(noteUpdated.IdNote, noteUpdate.Id);
			Assert.AreEqual(noteUpdated.IdAuteur, noteUpdate.IdAuteur);
			Assert.AreEqual(noteUpdated.IdCollaborateur, noteUpdate.Collaborateur.Id);
			Assert.AreEqual(noteUpdated.DateCreation, noteUpdate.DateCreation);
			Assert.AreEqual(noteUpdated.Titre, noteUpdate.Titre);
			Assert.AreEqual(noteUpdated.Texte, noteUpdate.Texte);
			Assert.AreEqual(noteUpdated.DateMiseAJour, noteUpdated.DateMiseAJour);
		}

		[TestCase(1)]
		[TestCase(2)]
		[TestCase(6)]
		[TestCase(9)]
		public async Task UpdateNote_UpdateTexte(long id)
		{
			INoteService noteService = new NoteService(collaborateurApi, collaborateurService, context);
			DetailsNoteDTO note = await noteService.GetNoteByIdAsync(id);
			note.Texte = "Texte à jour " + id;
			DetailsNoteDTO noteUpdate = await noteService.UpdateNoteAsync(id, note);
			Note noteUpdated = context.Note.Find(noteUpdate.Id);
			Assert.IsNotNull(noteUpdate);
			Assert.IsNotNull(noteUpdated);
			Assert.AreEqual(noteUpdated.IdNote, noteUpdate.Id);
			Assert.AreEqual(noteUpdated.IdAuteur, noteUpdate.IdAuteur);
			Assert.AreEqual(noteUpdated.IdCollaborateur, noteUpdate.Collaborateur.Id);
			Assert.AreEqual(noteUpdated.DateCreation, noteUpdate.DateCreation);
			Assert.AreEqual(noteUpdated.Titre, noteUpdate.Titre);
			Assert.AreEqual(noteUpdated.Texte, noteUpdate.Texte);
			Assert.AreEqual(noteUpdated.DateMiseAJour, noteUpdated.DateMiseAJour);
		}

		[TestCase(1)]
		[TestCase(2)]
		[TestCase(6)]
		[TestCase(9)]
		public async Task UpdateNote_UpdateTitre(long id)
		{
			INoteService noteService = new NoteService(collaborateurApi, collaborateurService, context);
			DetailsNoteDTO note = await noteService.GetNoteByIdAsync(id);
			note.Titre = "Titre à jour " + id;
			DetailsNoteDTO noteUpdate = await noteService.UpdateNoteAsync(id, note);
			Note noteUpdated = context.Note.Find(noteUpdate.Id);
			Assert.IsNotNull(noteUpdate);
			Assert.IsNotNull(noteUpdated);
			Assert.AreEqual(noteUpdated.IdNote, noteUpdate.Id);
			Assert.AreEqual(noteUpdated.IdAuteur, noteUpdate.IdAuteur);
			Assert.AreEqual(noteUpdated.IdCollaborateur, noteUpdate.Collaborateur.Id);
			Assert.AreEqual(noteUpdated.DateCreation, noteUpdate.DateCreation);
			Assert.AreEqual(noteUpdated.Titre, noteUpdate.Titre);
			Assert.AreEqual(noteUpdated.Texte, noteUpdate.Texte);
			Assert.AreEqual(noteUpdated.DateMiseAJour, noteUpdated.DateMiseAJour);
		}

		[TestCase(1,2)]
		[TestCase(1,3)]
		[TestCase(2,4)]
		[TestCase(2,5)]
		[TestCase(9,6)]
		[TestCase(9,7)]
		public async Task UpdateNote_NoteIdImcompatibleExceptionId(long id, long mauvaisId)
		{
			INoteService noteService = new NoteService(collaborateurApi, collaborateurService, context);
			DetailsNoteDTO note = await noteService.GetNoteByIdAsync(id);
			note.Titre = "Titre à jour " + id;
			note.Texte = "Texte à jour " + id;
			AsyncTestDelegate exception = () => noteService.UpdateNoteAsync(mauvaisId, note);
			Assert.ThrowsAsync(typeof(NoteIdImcompatibleException), exception);
		}

		[TestCase(1)]
		[TestCase(2)]
		[TestCase(6)]
		[TestCase(9)]
		public async Task UpdateNote_NoteIdImcompatibleExceptionDate(long id)
		{
			INoteService noteService = new NoteService(collaborateurApi, collaborateurService, context);
			DetailsNoteDTO note = await noteService.GetNoteByIdAsync(id);
			note.Titre = "Titre à jour " + id;
			note.Texte = "Texte à jour " + id;
			note.DateCreation = DateTime.Now;
			AsyncTestDelegate exception = () => noteService.UpdateNoteAsync(id, note);
			Assert.ThrowsAsync(typeof(NoteIdImcompatibleException), exception);
		}


		#endregion

		#region Tests GetNoteByAuteur
		#endregion.	


	}
}