Fusion de UnitTestEf dans master

API_SQLuedo/TestEF/Dto/TestBlackListDTO.cs

@@ -0,0 +1,18 @@
+using Dto;
+
+namespace TestEF.Dto;
+
+public class TestBlackListDTO
+{
+    private const string _email = "email@email.com";
+    private  DateOnly _date = new DateOnly(2025,01,21);
+
+
+    [Fact]
+    public void TestConstructorWithAllAttributes()
+    {
+        BlackListDTO inquiry = new BlackListDTO(_email,_date);
+        Assert.Equal(_email, inquiry.Email);
+        Assert.Equal(_date, inquiry.ExpirationDate);
+    }
+}

API_SQLuedo/TestEF/Mapper/BlackListMapperUnitTest.cs

@@ -0,0 +1,96 @@
+using Dto;
+using Entities;
+using Model;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Shared.Mapper;
+
+namespace TestEF.Mapper
+{
+    public class BlackListMapperUnitTest
+    {
+
+        private const string _email = "email@email.com";
+        private  DateOnly _date = new DateOnly(2024,12,21) ;
+
+
+        [Fact]
+        public void TestDtoToEntity()
+        {
+            BlackListDTO blacklist = new BlackListDTO(_email,_date);
+            var blackListEntity = blacklist.FromDTOToEntity();
+
+            Assert.NotNull(blackListEntity);
+            Assert.IsType<BlackListEntity>(blackListEntity);
+            Assert.Equal(_date, blackListEntity.ExpirationDate);
+            Assert.Equal(_email, blackListEntity.Email);
+
+        }
+
+        [Fact]
+        public void TestDtoToModel()
+        {
+            BlackListDTO blacklist = new BlackListDTO(_email,_date);
+            var blackListMod = blacklist.FromDTOToModel();
+
+            Assert.NotNull(blackListMod);
+            Assert.IsType<BlackList>(blackListMod);
+            Assert.Equal(_date, blackListMod.ExpirationDate);
+            Assert.Equal(_email, blackListMod.Email);
+
+        }
+
+        [Fact]
+        public void TestEntityToDto()
+        {
+            BlackListEntity blacklist = new BlackListEntity(_email,_date);
+            var blackListDto = blacklist.FromEntityToDTO();
+
+            Assert.NotNull(blackListDto);
+            Assert.IsType<BlackListDTO>(blackListDto);
+            Assert.Equal(_date, blackListDto.ExpirationDate);
+            Assert.Equal(_email, blackListDto.Email);
+        }
+
+        [Fact]
+        public void TestEntityToModel()
+        {
+            BlackListEntity blacklist = new BlackListEntity(_email,_date);
+            var blackListMod = blacklist.FromEntityToModel();
+
+            Assert.NotNull(blackListMod);
+            Assert.IsType<BlackList>(blackListMod);
+            Assert.Equal(_date, blackListMod.ExpirationDate);
+            Assert.Equal(_email, blackListMod.Email);
+        }
+
+
+
+        [Fact]
+        public void TestModelToDto()
+        {
+            BlackList blacklist = new BlackList(_email,_date);
+            var BlackListDto = blacklist.FromModelToDTO();
+
+            Assert.NotNull(BlackListDto);
+            Assert.IsType<BlackListDTO>(BlackListDto);
+            Assert.Equal(_date, BlackListDto.ExpirationDate);
+            Assert.Equal(_email, BlackListDto.Email);
+        }
+
+        [Fact]
+        public void TestModelToEntity()
+        {
+            BlackList blacklist = new BlackList(_email,_date);
+            var blackListEntity = blacklist.FromModelToEntity();
+
+            Assert.NotNull(blackListEntity);
+            Assert.IsType<BlackListEntity>(blackListEntity);
+            Assert.Equal(_date, blackListEntity.ExpirationDate);
+            Assert.Equal(_email, blackListEntity.Email);
+        }
+    }
+}

API_SQLuedo/TestEF/Mapper/InquiryMapperUnitTest.cs

@@ -0,0 +1,105 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Dto;
+using Entities;
+using Model;
+using Shared.Mapper;
+
+namespace TestEF.Mapper
+{
+    public class InquiryMapperUnitTest
+    {
+        private const int _id = 1;
+        private const string _title = "Title";
+        private const string _description = "_description";
+        private const bool _isUser = true;
+
+        [Fact]
+        public void TestDtoToEntity()
+        {
+            InquiryDTO inquiry = new InquiryDTO(_id, _title, _description, _isUser);
+            var inquiryEntity = inquiry.FromDTOToEntity();
+
+            Assert.NotNull(inquiryEntity);
+            Assert.IsType<InquiryEntity>(inquiryEntity);
+            Assert.Equal(1, inquiryEntity.Id);
+            Assert.Equal(_title, inquiryEntity.Title);
+            Assert.Equal(_description, inquiryEntity.Description);
+        }
+
+        [Fact]
+        public void TestEntityToDto()
+        {
+            InquiryEntity inquiry = new InquiryEntity(_id,_title, _description, _isUser);
+
+            var inquiryDto = inquiry.FromEntityToDTO();
+
+            Assert.NotNull(inquiryDto);
+            Assert.IsType<InquiryDTO>(inquiryDto);
+            Assert.Equal(1, inquiryDto.Id);
+            Assert.Equal(_title, inquiryDto.Title);
+            Assert.Equal(_description, inquiryDto.Description);
+        }
+
+
+        [Fact]
+        public void TestModelToEntity()
+        {
+            Inquiry inquiry = new Inquiry(_id, _title, _description, _isUser);
+            var inquiryEntity = inquiry.FromModelToEntity();
+
+            Assert.NotNull(inquiryEntity);
+            Assert.IsType<InquiryEntity>(inquiryEntity);
+            Assert.Equal(1, inquiryEntity.Id);
+            Assert.Equal(_title, inquiryEntity.Title);
+            Assert.Equal(_description, inquiryEntity.Description);
+        }
+
+        [Fact]
+        public void TestEntityToModel()
+        {
+            InquiryEntity inquiry = new InquiryEntity(_id,_title, _description, _isUser);
+
+            var inquiryMod = inquiry.FromEntityToModel();
+
+            Assert.NotNull(inquiryMod);
+            Assert.IsType<Inquiry>(inquiryMod);
+            Assert.Equal(1, inquiryMod.Id);
+            Assert.Equal(_title, inquiryMod.Title);
+            Assert.Equal(_description, inquiryMod.Description);
+        }
+
+
+
+        [Fact]
+        public void TestDtoToModel()
+        {
+            InquiryDTO inquiry = new InquiryDTO(_id, _title, _description, _isUser);
+            var inquiryMod = inquiry.FromDTOToEntity();
+
+            Assert.NotNull(inquiryMod);
+            Assert.IsType<InquiryEntity>(inquiryMod);
+            Assert.Equal(1, inquiryMod.Id);
+            Assert.Equal(_title, inquiryMod.Title);
+            Assert.Equal(_description, inquiryMod.Description);
+        }
+
+        [Fact]
+        public void TestModelToDto()
+        {
+            Inquiry inquiry = new Inquiry(_id,_title, _description, _isUser);
+
+            var inquiryDto = inquiry.FromModelToDTO();
+
+            Assert.NotNull(inquiryDto);
+            Assert.IsType<InquiryDTO>(inquiryDto);
+            Assert.Equal(1, inquiryDto.Id);
+            Assert.Equal(_title, inquiryDto.Title);
+            Assert.Equal(_description, inquiryDto.Description);
+        }
+
+    }
+}

API_SQLuedo/TestEF/Mapper/InquiryTableMapperUnitTest.cs

@@ -0,0 +1,104 @@
+using Dto;
+using Entities;
+using Model;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Shared.Mapper;
+
+namespace TestEF.Mapper
+{
+    public class InquiryTableMapperUnitTest
+    {
+
+        private const int _ownerId = 1;
+        private const string _databaseName = "Nom";
+        private const string _connectionInfo = "Infos";
+        
+
+
+        [Fact]
+        public void TestDtoToEntity()
+        {
+            InquiryTableDTO inquiryTable = new InquiryTableDTO(_ownerId,_databaseName,_connectionInfo);
+            var inquiryTableEntity = inquiryTable.FromDTOToEntity();
+
+            Assert.NotNull(inquiryTableEntity);
+            Assert.IsType<InquiryTableEntity>(inquiryTableEntity);
+            Assert.Equal(_ownerId, inquiryTableEntity.OwnerId);
+            Assert.Equal(_databaseName, inquiryTableEntity.DatabaseName);
+            Assert.Equal(_connectionInfo, inquiryTableEntity.ConnectionInfo);
+
+        }
+
+        [Fact]
+        public void TestDtoToModel()
+        {
+            InquiryTableDTO inquiryTable = new InquiryTableDTO(_ownerId,_databaseName,_connectionInfo);
+            var inquiryTableMod = inquiryTable.FromDTOToModel();
+
+            Assert.NotNull(inquiryTableMod);
+            Assert.IsType<InquiryTable>(inquiryTableMod);
+            Assert.Equal(_ownerId, inquiryTableMod.OwnerId);
+            Assert.Equal(_databaseName, inquiryTableMod.ConnectionInfo);
+            Assert.Equal(_connectionInfo, inquiryTableMod.DatabaseName);
+
+        }
+
+        [Fact]
+        public void TestEntityToDto()
+        {
+            InquiryTableEntity inquiryTable = new InquiryTableEntity(_ownerId,_databaseName,_connectionInfo);
+            var inquiryTableDto = inquiryTable.FromEntityToDTO();
+
+            Assert.NotNull(inquiryTableDto);
+            Assert.IsType<InquiryTableDTO>(inquiryTableDto);
+            Assert.Equal(_ownerId, inquiryTableDto.OwnerId);
+            Assert.Equal(_databaseName, inquiryTableDto.DatabaseName);
+            Assert.Equal(_connectionInfo, inquiryTableDto.ConnectionInfo);
+        }
+
+        [Fact]
+        public void TestEntityToModel()
+        {
+            InquiryTableEntity inquiryTable = new InquiryTableEntity(_ownerId,_databaseName,_connectionInfo);
+            var inquiryTableMod = inquiryTable.FromEntityToModel();
+
+            Assert.NotNull(inquiryTableMod);
+            Assert.IsType<InquiryTable>(inquiryTableMod);
+            Assert.Equal(_ownerId, inquiryTableMod.OwnerId);
+            Assert.Equal(_databaseName, inquiryTableMod.ConnectionInfo);
+            Assert.Equal(_connectionInfo, inquiryTableMod.DatabaseName);
+        }
+
+
+
+        [Fact]
+        public void TestModelToDto()
+        {
+            InquiryTable inquiryTable = new InquiryTable(_ownerId,_databaseName,_connectionInfo);
+            var inquiryTableDto = inquiryTable.FromModelToDTO();
+
+            Assert.NotNull(inquiryTableDto);
+            Assert.IsType<InquiryTableDTO>(inquiryTableDto);
+            Assert.Equal(_ownerId, inquiryTableDto.OwnerId);
+            Assert.Equal(_databaseName, inquiryTableDto.DatabaseName);
+            Assert.Equal(_connectionInfo, inquiryTableDto.ConnectionInfo);
+        }
+
+        [Fact]
+        public void TestModelToEntity()
+        {
+            InquiryTable inquiryTable = new InquiryTable(_ownerId,_databaseName,_connectionInfo);
+            var inquiryTableEntity = inquiryTable.FromModelToEntity();
+
+            Assert.NotNull(inquiryTableEntity);
+            Assert.IsType<InquiryTableEntity>(inquiryTableEntity);
+            Assert.Equal(_ownerId, inquiryTableEntity.OwnerId);
+            Assert.Equal(_databaseName, inquiryTableEntity.DatabaseName);
+            Assert.Equal(_connectionInfo, inquiryTableEntity.ConnectionInfo);
+        }
+    }
+}

API_SQLuedo/TestEF/Mapper/LessonMapperUnitTest.cs

@@ -0,0 +1,105 @@
+using Dto;
+using Entities;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Shared.Mapper;
+using Model;
+
+namespace TestEF.Mapper
+{
+    public class LessonMapperUnitTest
+    {
+        private const int _id = 1;
+        private const string _title = "Title";
+        private const string _lastPublisher = "_lastPublisher";
+        private DateOnly date = new DateOnly(2024,03,02);
+
+        [Fact]
+        public void TestDtoToEntity()
+        {
+            LessonDTO lesson = new LessonDTO(_id, _title, _lastPublisher, date);
+            var lessonEntity = lesson.FromDTOToEntity();
+
+            Assert.NotNull(lessonEntity);
+            Assert.IsType<LessonEntity>(lessonEntity);
+            Assert.Equal(1, lessonEntity.Id);
+            Assert.Equal(_title, lessonEntity.Title);
+            Assert.Equal(_lastPublisher, lessonEntity.LastPublisher);
+        }
+
+
+        [Fact]
+        public void TestDtoToModel()
+        {
+            LessonDTO lesson = new LessonDTO(_id, _title, _lastPublisher, date);
+            var lessonMod = lesson.FromDTOToModel();
+
+            Assert.NotNull(lessonMod);
+            Assert.IsType<Lesson>(lessonMod);
+            Assert.Equal(1, lessonMod.Id);
+            Assert.Equal(_title, lessonMod.Title);
+            Assert.Equal(_lastPublisher, lessonMod.LastPublisher);
+        }
+
+        [Fact]
+        public void TestEntityToDto()
+        {
+            LessonEntity lesson = new LessonEntity(_id,_title, _lastPublisher, date);
+
+            var lessonDto = lesson.FromEntityToDTO();
+
+            Assert.NotNull(lessonDto);
+            Assert.IsType<LessonDTO>(lessonDto);
+            Assert.Equal(1, lessonDto.Id);
+            Assert.Equal(_title, lessonDto.Title);
+            Assert.Equal(_lastPublisher, lessonDto.LastPublisher);
+        }
+
+        [Fact]
+        public void TestEntityToModel()
+        {
+            LessonEntity lesson = new LessonEntity(_id, _title, _lastPublisher, date);
+
+            var lessonMod = lesson.FromEntityToModel();
+
+            Assert.NotNull(lessonMod);
+            Assert.IsType<Lesson>(lessonMod);
+            Assert.Equal(1, lessonMod.Id);
+            Assert.Equal(_title, lessonMod.Title);
+            Assert.Equal(_lastPublisher, lessonMod.LastPublisher);
+        }
+
+
+
+        [Fact]
+        public void TestModelToDto()
+        {
+            Lesson lesson = new Lesson(_id, _title, _lastPublisher, date);
+
+            var lessonDto = lesson.FromModelToDTO();
+
+            Assert.NotNull(lessonDto);
+            Assert.IsType<LessonDTO>(lessonDto);
+            Assert.Equal(1, lessonDto.Id);
+            Assert.Equal(_title, lessonDto.Title);
+            Assert.Equal(_lastPublisher, lessonDto.LastPublisher);
+        }
+
+        [Fact]
+        public void TestModelToEntity()
+        {
+            Lesson lesson = new Lesson(_id, _title, _lastPublisher, date);
+
+            var lessonEntity = lesson.FromModelToEntity();
+
+            Assert.NotNull(lessonEntity);
+            Assert.IsType<LessonEntity>(lessonEntity);
+            Assert.Equal(1, lessonEntity.Id);
+            Assert.Equal(_title, lessonEntity.Title);
+            Assert.Equal(_lastPublisher, lessonEntity.LastPublisher);
+        }
+    }
+}

API_SQLuedo/TestEF/Mapper/NotepadMapperUnitTest.cs

@@ -0,0 +1,111 @@
+using Dto;
+using Entities;
+using Model;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Shared.Mapper;
+
+namespace TestEF.Mapper
+{
+    public class NotepadMapperUnitTest
+    {
+
+        private const int _id = 1;
+        private const int _userId = 1;
+        private const int _inquiryId = 2;
+        private const string _notes = "Notes";
+
+
+
+        [Fact]
+        public void TestDtoToEntity()
+        {
+            NotepadDTO notepad = new NotepadDTO(_id,_userId,_inquiryId,_notes);
+            var notepadEntity = notepad.FromDTOToEntity();
+
+            Assert.NotNull(notepadEntity);
+            Assert.IsType<NotepadEntity>(notepadEntity);
+            Assert.Equal(0, notepadEntity.Id);
+            Assert.Equal(_userId, notepadEntity.UserId);
+            Assert.Equal(1, notepadEntity.InquiryId);
+            Assert.Equal(_notes, notepadEntity.Notes);
+
+        }
+
+        [Fact]
+        public void TestDtoToModel()
+        {
+            NotepadDTO notepad = new NotepadDTO(_id,_userId,_inquiryId,_notes);
+            var notepadMod = notepad.FromDTOToModel();
+
+            Assert.NotNull(notepadMod);
+            Assert.IsType<Notepad>(notepadMod);
+            Assert.Equal(_id, notepadMod.Id);
+            Assert.Equal(_userId, notepadMod.UserId);
+            Assert.Equal(_inquiryId, notepadMod.InquiryId);
+            Assert.Equal(_notes, notepadMod.Notes);
+
+        }
+
+        [Fact]
+        public void TestEntityToDto()
+        {
+            NotepadEntity notepad = new NotepadEntity(_id, new UserEntity(), _inquiryId, new InquiryEntity(), _notes);
+            var NotepadDTO = notepad.FromEntityToDTO();
+
+            Assert.NotNull(NotepadDTO);
+            Assert.IsType<NotepadDTO>(NotepadDTO);
+            Assert.Equal(0, NotepadDTO.Id);
+            Assert.Equal(_userId, NotepadDTO.UserId);
+            Assert.Equal(_inquiryId, NotepadDTO.InquiryId);
+            Assert.Equal(_notes, NotepadDTO.Notes);
+        }
+
+        [Fact]
+        public void TestEntityToModel()
+        {
+            NotepadEntity notepad = new NotepadEntity(_id,new UserEntity(),_inquiryId,new InquiryEntity(),_notes);
+            var notepadMod = notepad.FromEntityToModel();
+
+            Assert.NotNull(notepadMod);
+            Assert.IsType<Notepad>(notepadMod);
+            Assert.Equal(0, notepadMod.Id);
+            Assert.Equal(_userId, notepadMod.UserId);
+            Assert.Equal(2, notepadMod.InquiryId);
+            Assert.Equal(_notes, notepadMod.Notes);
+        }
+
+
+
+        [Fact]
+        public void TestModelToDto()
+        {
+            Notepad notepad = new Notepad(_id,_userId,_inquiryId,_notes);
+            var NotepadDTO = notepad.FromModelToDTO();
+
+            Assert.NotNull(NotepadDTO);
+            Assert.IsType<NotepadDTO>(NotepadDTO);
+            Assert.Equal(_id, NotepadDTO.Id);
+            Assert.Equal(_userId, NotepadDTO.UserId);
+            Assert.Equal(_inquiryId, NotepadDTO.InquiryId);
+            Assert.Equal(_notes, NotepadDTO.Notes);
+        }
+
+        [Fact]
+        public void TestModelToEntity()
+        {
+            Notepad notepad = new Notepad(_id,_userId,_inquiryId,_notes);
+            var notepadEntity = notepad.FromModelToEntity();
+
+            Assert.NotNull(notepadEntity);
+            Assert.IsType<NotepadEntity>(notepadEntity);
+            Assert.Equal(0, notepadEntity.Id);
+            Assert.Equal(_userId, notepadEntity.UserId);
+            Assert.Equal(1, notepadEntity.InquiryId);
+            Assert.Equal(_notes, notepadEntity.Notes);
+        }
+    }
+}

API_SQLuedo/TestEF/Mapper/ParagraphMapperUnitTest.cs

@@ -0,0 +1,131 @@
+using Dto;
+using Entities;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Model;
+using Shared.Mapper;
+using SQLitePCL;
+
+namespace TestEF.Mapper
+{
+    public class ParagraphMapperUnitTest
+    {
+
+        private const int _id = 1;
+        private const string _title = "Title";
+        private const string _content = "Contenu";
+
+        private const string _info = "Info";
+        private const string _query = "Requête";
+        private const string _comment = "Comment";
+        private const int _lessonId = 2;
+
+        [Fact]
+        public void TestDtoToEntity()
+        {
+            ParagraphDTO paragraph = new ParagraphDTO(_id,_title,_content,_info,_query,_comment,_lessonId);
+            var paragrahEntity = paragraph.FromDTOToEntity();
+
+            Assert.NotNull(paragrahEntity);
+            Assert.IsType<ParagraphEntity>(paragrahEntity);
+            Assert.Equal(1, paragrahEntity.Id);
+            Assert.Equal(_title, paragrahEntity.Title);
+            Assert.Equal(_content, paragrahEntity.Content);
+            Assert.Equal(_info, paragrahEntity.Info);
+            Assert.Equal(_query, paragrahEntity.Query);
+            Assert.Equal(_comment, paragrahEntity.Comment);
+            Assert.Equal(_lessonId, paragrahEntity.LessonId);
+
+        }
+
+
+        [Fact]
+        public void TestDtoToModel()
+        {
+            ParagraphDTO paragraph = new ParagraphDTO(_id, _title, _content, _info, _query, _comment, _lessonId);
+            var paragraphMod = paragraph.FromDTOToModel();
+
+            Assert.NotNull(paragraphMod);
+            Assert.IsType<Paragraph>(paragraphMod);
+            Assert.Equal(0, paragraphMod.Id);
+            Assert.Equal(_info, paragraphMod.Info);
+            Assert.Equal(_query, paragraphMod.Query);
+            Assert.Equal(_comment, paragraphMod.Comment);
+            Assert.Equal(0, paragraphMod.LessonId);
+
+        }
+
+        [Fact]
+        public void TestEntityToDto()
+        {
+            ParagraphEntity paragraph = new ParagraphEntity(_id, _title, _content, _info, _query, _comment, _lessonId);
+            var paragraphDTO = paragraph.FromEntityToDTO();
+
+            Assert.NotNull(paragraphDTO);
+            Assert.IsType<ParagraphDTO>(paragraphDTO);
+            Assert.Equal(1, paragraphDTO.Id);
+            Assert.Equal(_title, paragraphDTO.Title);
+            Assert.Equal(_content, paragraphDTO.Content);
+            Assert.Equal(_info, paragraphDTO.Info);
+            Assert.Equal(_query, paragraphDTO.Query);
+            Assert.Equal(_comment, paragraphDTO.Comment);
+            Assert.Equal(_lessonId, paragraphDTO.LessonId);
+        }
+
+
+        [Fact]
+        public void TestEntityToModel()
+        {
+            ParagraphEntity paragraph = new ParagraphEntity(_id, _title, _content, _info, _query, _comment, _lessonId);
+            var paragrahMod = paragraph.FromEntityToModel();
+
+            Assert.NotNull(paragrahMod);
+            Assert.IsType<Paragraph>(paragrahMod);
+            Assert.Equal(0, paragrahMod.Id);
+            Assert.Equal(_info, paragrahMod.Info);
+            Assert.Equal(_query, paragrahMod.Query);
+            Assert.Equal(_comment, paragrahMod.Comment);
+            Assert.Equal(0, paragrahMod.LessonId);
+        }
+
+
+
+        [Fact]
+        public void TestModelToDto()
+        {
+            Paragraph paragraph = new Paragraph(_id, _title, _content, _info, _query, _comment, _lessonId);
+            var paragrahDTO = paragraph.FromModelToDTO();
+
+            Assert.NotNull(paragrahDTO);
+            Assert.IsType<ParagraphDTO>(paragrahDTO);
+            Assert.Equal(1, paragrahDTO.Id);
+            Assert.Equal(_title, paragrahDTO.Title);
+            Assert.Equal(_content, paragrahDTO.Content);
+            Assert.Equal(_info, paragrahDTO.Info);
+            Assert.Equal(_query, paragrahDTO.Query);
+            Assert.Equal(_comment, paragrahDTO.Comment);
+            Assert.Equal(_lessonId, paragrahDTO.LessonId);
+        }
+
+
+        [Fact]
+        public void TestModelToEntity()
+        {
+            ParagraphEntity paragraph = new ParagraphEntity(_id, _title, _content, _info, _query, _comment, _lessonId);
+            var paragrahEntity = paragraph.FromEntityToDTO();
+
+            Assert.NotNull(paragrahEntity);
+            Assert.IsType<ParagraphDTO>(paragrahEntity);
+            Assert.Equal(1, paragrahEntity.Id);
+            Assert.Equal(_title, paragrahEntity.Title);
+            Assert.Equal(_content, paragrahEntity.Content);
+            Assert.Equal(_info, paragrahEntity.Info);
+            Assert.Equal(_query, paragrahEntity.Query);
+            Assert.Equal(_comment, paragrahEntity.Comment);
+            Assert.Equal(_lessonId, paragrahEntity.LessonId);
+        }
+    }
+}

API_SQLuedo/TestEF/Mapper/SolutionMapperUnitTest.cs

@@ -0,0 +1,125 @@
+using Dto;
+using Entities;
+using Model;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Shared.Mapper;
+
+namespace TestEF.Mapper
+{
+    public class SolutionMapperUnitTest
+    {
+
+        private const int _ownerId = 1;
+        private const string _murdererFirstName = "Jacques";
+        private const string _murdererLastName = "Chirac";
+        private const string _murderPlace = "Bureau de richard";
+        private const string _murderWeapon = "Les mots";
+        private const string _explanation = "Y'en a pas";
+
+
+
+        [Fact]
+        public void TestDtoToEntity()
+        {
+            SolutionDTO solution = new SolutionDTO(_ownerId,_murdererFirstName,_murdererLastName,_murderPlace,_murderWeapon,_explanation);
+            var solutionEntity = solution.FromDTOToEntity();
+
+            Assert.NotNull(solutionEntity);
+            Assert.IsType<SolutionEntity>(solutionEntity);
+            Assert.Equal(_ownerId, solutionEntity.OwnerId);
+            Assert.Equal(_murdererFirstName, solutionEntity.MurdererFirstName);
+            Assert.Equal(_murdererLastName, solutionEntity.MurdererLastName);
+            Assert.Equal(_murderPlace, solutionEntity.MurderPlace);
+            Assert.Equal(_murderWeapon, solutionEntity.MurderWeapon);
+            Assert.Equal(_explanation, solutionEntity.Explaination);
+
+        }
+
+        [Fact]
+        public void TestDtoToModel()
+        {
+            SolutionDTO solution = new SolutionDTO(_ownerId, _murdererFirstName, _murdererLastName, _murderPlace, _murderWeapon, _explanation);
+            var solutionMod = solution.FromDTOToModel();
+
+            Assert.NotNull(solutionMod);
+            Assert.IsType<Solution>(solutionMod);
+            Assert.Equal(_ownerId, solutionMod.OwnerId);
+            Assert.Equal(_murdererFirstName, solutionMod.MurdererFirstName);
+            Assert.Equal(_murdererLastName, solutionMod.MurdererLastName);
+            Assert.Equal(_murderPlace, solutionMod.MurderPlace);
+            Assert.Equal(_murderWeapon, solutionMod.MurderWeapon);
+            Assert.Equal(_explanation, solutionMod.Explanation);
+
+        }
+
+        [Fact]
+        public void TestEntityToDto()
+        {
+            SolutionEntity solution = new SolutionEntity(_ownerId, _murdererFirstName, _murdererLastName, _murderPlace, _murderWeapon, _explanation);
+            var solutionDto = solution.FromEntityToDTO();
+
+            Assert.NotNull(solutionDto);
+            Assert.IsType<SolutionDTO>(solutionDto);
+            Assert.Equal(_ownerId, solutionDto.OwnerId);
+            Assert.Equal(_murdererFirstName, solutionDto.MurdererFirstName);
+            Assert.Equal(_murdererLastName, solutionDto.MurdererLastName);
+            Assert.Equal(_murderPlace, solutionDto.MurderPlace);
+            Assert.Equal(_murderWeapon, solutionDto.MurderWeapon);
+            Assert.Equal(_explanation, solutionDto.Explanation);
+        }
+
+        [Fact]
+        public void TestEntityToModel()
+        {
+            SolutionEntity solution = new SolutionEntity(_ownerId, _murdererFirstName, _murdererLastName, _murderPlace, _murderWeapon, _explanation);
+            var solutionMod = solution.FromEntityToModel();
+
+            Assert.NotNull(solutionMod);
+            Assert.IsType<Solution>(solutionMod);
+            Assert.Equal(_ownerId, solutionMod.OwnerId);
+            Assert.Equal(_murdererFirstName, solutionMod.MurdererFirstName);
+            Assert.Equal(_murdererLastName, solutionMod.MurdererLastName);
+            Assert.Equal(_murderPlace, solutionMod.MurderPlace);
+            Assert.Equal(_murderWeapon, solutionMod.MurderWeapon);
+            Assert.Equal(_explanation, solutionMod.Explanation);
+        }
+
+
+
+        [Fact]
+        public void TestModelToDto()
+        {
+            Solution solution = new Solution(_ownerId, _murdererFirstName, _murdererLastName, _murderPlace, _murderWeapon, _explanation);
+            var solutionDto = solution.FromModelToDTO();
+
+            Assert.NotNull(solutionDto);
+            Assert.IsType<SolutionDTO>(solutionDto);
+            Assert.Equal(_ownerId, solutionDto.OwnerId);
+            Assert.Equal(_murdererFirstName, solutionDto.MurdererFirstName);
+            Assert.Equal(_murdererLastName, solutionDto.MurdererLastName);
+            Assert.Equal(_murderPlace, solutionDto.MurderPlace);
+            Assert.Equal(_murderWeapon, solutionDto.MurderWeapon);
+            Assert.Equal(_explanation, solutionDto.Explanation);
+        }
+
+        [Fact]
+        public void TestModelToEntity()
+        {
+            Solution solution = new Solution(_ownerId,_murdererFirstName,_murdererLastName,_murderPlace,_murderWeapon,_explanation);
+            var solutionEntity = solution.FromModelToEntity();
+
+            Assert.NotNull(solutionEntity);
+            Assert.IsType<SolutionEntity>(solutionEntity);
+            Assert.Equal(_ownerId, solutionEntity.OwnerId);
+            Assert.Equal(_murdererFirstName, solutionEntity.MurdererFirstName);
+            Assert.Equal(_murdererLastName, solutionEntity.MurdererLastName);
+            Assert.Equal(_murderPlace, solutionEntity.MurderPlace);
+            Assert.Equal(_murderWeapon, solutionEntity.MurderWeapon);
+            Assert.Equal(_explanation, solutionEntity.Explaination);
+        }
+    }
+}

API_SQLuedo/TestEF/Mapper/SuccessMapperUnitTest.cs

@@ -0,0 +1,104 @@
+using Dto;
+using Entities;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Model;
+using Shared.Mapper;
+
+namespace TestEF.Mapper
+{
+    public class SuccessMapperUnitTest
+    {
+
+        private const int _userId = 1;
+        private const int _inquiryId = 2;
+        private const bool _isFinished = true;
+
+        [Fact]
+        public void TestDtoToEntity()
+        {
+            SuccessDTO success = new SuccessDTO(_userId, _inquiryId, _isFinished);
+            var successEntity = success.FromDTOToEntity();
+
+            Assert.NotNull(successEntity);
+            Assert.IsType<SuccessEntity>(successEntity);
+            Assert.Equal(1, successEntity.UserId);
+            Assert.Equal(2, successEntity.InquiryId);
+            Assert.True(successEntity.IsFinished);
+
+        }
+
+        [Fact]
+
+        public void TestDtoToModel()
+        {
+            SuccessDTO success = new SuccessDTO(_userId, _inquiryId, _isFinished);
+            var successMod = success.FromDTOToModel();
+
+            Assert.NotNull(successMod);
+            Assert.IsType<Success>(successMod);
+            Assert.Equal(1, successMod.UserId);
+            Assert.Equal(2, successMod.InquiryId);
+            Assert.True(successMod.IsFinished);
+
+        }
+
+        [Fact]
+        public void TestEntityToDto()
+        {
+            SuccessEntity success = new SuccessEntity(_userId, _inquiryId, _isFinished);
+            var successDto = success.FromEntityToDTO();
+
+            Assert.NotNull(successDto);
+            Assert.IsType<SuccessDTO>(successDto);
+            Assert.Equal(1, successDto.UserId);
+            Assert.Equal(2, successDto.InquiryId);
+            Assert.True(successDto.IsFinished);
+        }
+
+        [Fact]
+        public void TestEntityToModel()
+        {
+            SuccessEntity success = new SuccessEntity(_userId, _inquiryId, _isFinished);
+            var successMod = success.FromEntityToModel();
+
+            Assert.NotNull(successMod);
+            Assert.IsType<Success>(successMod);
+            Assert.Equal(1, successMod.UserId);
+            Assert.Equal(2, successMod.InquiryId);
+            Assert.True(successMod.IsFinished);
+        }
+
+
+
+
+        [Fact]
+        public void TestModelToDto()
+        {
+            Success success = new Success(_userId, _inquiryId, _isFinished);
+            var successDto = success.FromModelToDTO();
+
+            Assert.NotNull(successDto);
+            Assert.IsType<SuccessDTO>(successDto);
+            Assert.Equal(1, successDto.UserId);
+            Assert.Equal(2, successDto.InquiryId);
+            Assert.True((bool)successDto.IsFinished);
+        }
+
+        [Fact]
+        public void TestModelToEntity()
+        {
+            Success success = new Success(_userId, _inquiryId, _isFinished);
+            var successEntity = success.FromModelToEntity();
+
+            Assert.NotNull(successEntity);
+            Assert.IsType<SuccessEntity>(successEntity);
+            Assert.Equal(1, successEntity.UserId);
+            Assert.Equal(2, successEntity.InquiryId);
+            Assert.True(successEntity.IsFinished);
+        }
+    }
+}

API_SQLuedo/TestEF/Mapper/UserMapperUnitTest.cs

@@ -0,0 +1,116 @@
+using Dto;
+using Entities;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Model;
+using Shared.Mapper;
+
+namespace TestEF.Mapper
+{
+    public class UserMapperUnitTest
+    {
+
+        private const int _userId = 1;
+        private const string _username = "Username";
+        private const string _password = "password";
+        private const string _email = "email@email.com";
+        private const bool _isAdmin = true;
+
+        [Fact]
+        public void TestDtoToEntity()
+        {
+            UserDTO user = new UserDTO(_userId,_username,_password,_email,_isAdmin);
+            var userEntity = user.FromDTOToEntity();
+
+            Assert.NotNull(userEntity);
+            Assert.IsType<UserEntity>(userEntity);
+            Assert.Equal(1, userEntity.Id);
+            Assert.Equal("Username", userEntity.Username);
+            Assert.Equal("password", userEntity.Password);
+            Assert.Equal("email@email.com", userEntity.Email);
+            Assert.True(userEntity.IsAdmin);
+
+        }
+
+        [Fact]
+        public void TestDtoToModel()
+        {
+            UserDTO user = new UserDTO(_userId, _username, _password, _email, _isAdmin);
+            var userMod = user.FromDTOToModel();
+
+            Assert.NotNull(userMod);
+            Assert.IsType<User>(userMod);
+            Assert.Equal(1, userMod.Id);
+            Assert.Equal("Username", userMod.Username);
+            Assert.Equal("password", userMod.Password);
+            Assert.Equal("email@email.com", userMod.Email);
+            Assert.True(userMod.IsAdmin);
+
+        }
+
+        [Fact]
+        public void TestEntityToDto()
+        {
+            UserEntity user = new UserEntity(_userId, _username, _password, _email, _isAdmin);
+            var userEntity = user.FromEntityToDTO();
+
+            Assert.NotNull(userEntity);
+            Assert.IsType<UserDTO>(userEntity);
+            Assert.Equal(1, userEntity.Id);
+            Assert.Equal("Username", userEntity.Username);
+            Assert.Equal("password", userEntity.Password);
+            Assert.Equal("email@email.com", userEntity.Email);
+            Assert.True(userEntity.IsAdmin);
+        }
+
+        [Fact]
+        public void TestEntityToModel()
+        {
+            UserEntity user = new UserEntity(_userId, _username, _password, _email, _isAdmin);
+            var userMod = user.FromEntityToModel();
+
+            Assert.NotNull(userMod);
+            Assert.IsType<User>(userMod);
+            Assert.Equal(1, userMod.Id);
+            Assert.Equal("Username", userMod.Username);
+            Assert.Equal("password", userMod.Password);
+            Assert.Equal("email@email.com", userMod.Email);
+            Assert.True(userMod.IsAdmin);
+        }
+
+
+
+        [Fact]
+        public void TestModelToDto()
+        {
+            User user = new User(_userId, _username, _password, _email, _isAdmin);
+            var userDto = user.FromModelToDTO();
+
+            Assert.NotNull(userDto);
+            Assert.IsType<UserDTO>(userDto);
+            Assert.Equal(1, userDto.Id);
+            Assert.Equal("Username", userDto.Username);
+            Assert.Equal("password", userDto.Password);
+            Assert.Equal("email@email.com", userDto.Email);
+            Assert.True(userDto.IsAdmin);
+        }
+
+        [Fact]
+        public void TestModelToEntity()
+        {
+            User user = new User(_userId, _username, _password, _email, _isAdmin);
+            var userEntity = user.FromModelToEntity();
+
+            Assert.NotNull(userEntity);
+            Assert.IsType<UserEntity>(userEntity);
+            Assert.Equal(1, userEntity.Id);
+            Assert.Equal("Username", userEntity.Username);
+            Assert.Equal("password", userEntity.Password);
+            Assert.Equal("email@email.com", userEntity.Email);
+            Assert.True(userEntity.IsAdmin);
+        }
+    }
+}