Fusion master dans LinkBlazor

.drone.yml

@@ -30,7 +30,7 @@ steps:
       sonar_token:
         from_secret: SECRET_SONAR_LOGIN
       project_key: API_SQLuedo
-      coverage_exclusions: "Test*/**"
+      coverage_exclusions: "**/Test*/**,**/*Context*/**,**/Program.cs"
     commands:
       - cd API_SQLuedo/
       - dotnet restore API_SQLuedo.sln
@@ -41,3 +41,19 @@ steps:
       - dotnet publish API_SQLuedo.sln -c Release --no-restore -o CI_PROJECT_DIR/build/release
       - dotnet sonarscanner end /d:sonar.login=$${sonar_token}
     depends_on: [ build ]
+
+  - name: deploy-sqluedo-db
+    image: hub.codefirst.iut.uca.fr/thomas.bellembois/codefirst-dockerproxy-clientdrone:latest
+    environment:
+      IMAGENAME: postgres:16.2
+      CONTAINERNAME: sqluedo-db
+      COMMAND: create
+      OVERWRITE: true
+      PRIVATE: true
+      CODEFIRST_CLIENTDRONE_ENV_POSTGRES_USER:
+        from_secret: db_username
+      CODEFIRST_CLIENTDRONE_ENV_POSTGRES_PASSWORD:
+        from_secret: db_password
+      CODEFIRST_CLIENTDRONE_ENV_POSTGRES_DB:
+        from_secret: db_database
+      ADMINS: erwanmenager,maximesapountzis,johnnyratton,victorgaborit,clementchieu 

API_SQLuedo/API/Controllers/BlackListController.cs

@@ -0,0 +1,94 @@
+using Asp.Versioning;
+using Dto;
+using Entities;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Mvc;
+using Model.OrderCriteria;
+using Shared;
+using Shared.Mapper;
+
+namespace API.Controllers;
+
+[Route("api/v{version:apiVersion}/[controller]")]
+[Authorize]
+[ApiVersion("1.0")]
+[ApiController]
+public class BlackListController(ILogger<UsersController> logger, IBlackListService<BlackListDto> blackListService) : ControllerBase
+{
+    [HttpGet("user/ban/{page:int}/{number:int}")]
+    [ProducesResponseType(typeof(IEnumerable<BlackListDto>), 200)]
+    [ProducesResponseType(typeof(string), 204)]
+    public IActionResult GetBannedUsers(int page, int number, BlackListOdrerCriteria orderCriteria)
+    {
+        var users = blackListService.GetBannedUsers(page, number, orderCriteria).ToList();
+        if (users.Count == 0)
+        {
+            logger.LogError("[ERREUR] Aucun email banni trouvé.");
+            return StatusCode(204);
+        }
+
+        logger.LogInformation("[INFORMATION] {nb} Email(s) banni(s) trouvé(s)", users.Count);
+        return Ok(users);
+    }
+    
+    [HttpGet("user/ban/number")]
+    [ProducesResponseType(typeof(UserDto), 200)]
+    [ProducesResponseType(typeof(string), 204)]
+    public IActionResult GetNumberOfBannedUsers()
+    {
+        var nb = blackListService.GetNumberOfBannedUsers();
+        logger.LogInformation("[INFORMATION] {nb} Email(s) banni(s) trouvé(s)", nb);
+        return Ok(new KeyValuePair<string,int>("number",nb));
+    }
+    
+    [HttpPost("user/ban")]
+    [ProducesResponseType(typeof(UserDto), 200)]
+    [ProducesResponseType(typeof(string), 404)]
+    public IActionResult GetUserBannedByEmail([FromBody] string email)
+    {
+        var res = blackListService.GetUserBannedByEmail(email);
+        if (res != null)
+        {
+            logger.LogInformation("[INFORMATION] Utilisateur banni avec l'email {email} a été trouvé.", email);
+            return Ok(res);   
+        }
+        logger.LogError("[ERREUR] Aucun utilisateur banni trouvé avec l'email {email}.", email);
+        return NotFound("Utilisateur non trouvé !");
+    }
+    
+    [HttpDelete("user/ban/{username:alpha}")]
+    [ProducesResponseType(typeof(UserDto), 200)]
+    [ProducesResponseType(typeof(string), 404)]
+    public IActionResult BanUser(string username)
+    {
+        var success = blackListService.BanUser(username);
+        if (success)
+        {
+            logger.LogInformation("[INFORMATION] L'utilisateur avec le pseudo {username} a été banni pour 2 ans.", username);
+            return Ok(new KeyValuePair<string,bool>("success", true));
+        }
+        else
+        {
+            logger.LogError("[ERREUR] Aucun utilisateur trouvé avec le pseudo {username}.", username);
+            return NotFound();
+        }
+    }
+    
+    [HttpPost("user/unban")]
+    [ProducesResponseType(typeof(UserDto), 200)]
+    [ProducesResponseType(typeof(string), 404)]
+    public IActionResult UnbanUser([FromBody] string email)
+    {
+        var success = blackListService.UnbanUser(email);
+        if (success)
+        {
+            logger.LogInformation("[INFORMATION] L'utilisateur avec l'email {email} a été débanni.", email);
+            return Ok(new KeyValuePair<string,bool>("success", true));
+        }
+        else
+        {
+            logger.LogError("[ERREUR] Aucun utilisateur banni trouvé avec l'email {email}.", email);
+            return NotFound();
+        }
+    }
+}

API_SQLuedo/API/Controllers/InquiriesController.cs

@@ -39,6 +39,16 @@ namespace API.Controllers
             return Ok(_inquiryDataService.GetInquiries(page, number, orderCriteria));
         }
         
+        [HttpGet("inquiries/number")]
+        [ProducesResponseType(typeof(InquiryDto), 200)]
+        [ProducesResponseType(typeof(string), 204)]
+        public IActionResult GetNumberOfInquiries()
+        {
+            var nbInquiry = _inquiryDataService.GetNumberOfInquiries();
+            _logger.LogInformation("[INFORMATION] {nb} Enquête(s) trouvée(s)", nbInquiry);
+            return Ok(new KeyValuePair<string,int>("nbInquiries", nbInquiry));
+        }
+
         [HttpGet("inquiry/{id:int}")]
         [ProducesResponseType(typeof(InquiryDto), 200)]
         [ProducesResponseType(typeof(string), 404)]

API_SQLuedo/API/Controllers/UserController.cs

@@ -29,6 +29,38 @@ namespace API.Controllers
             return Ok(users);
         }
         
+        [HttpGet("users/not-admin/{page:int}/{number:int}")]
+        [ProducesResponseType(typeof(UserDto), 200)]
+        [ProducesResponseType(typeof(string), 204)]
+        public IActionResult GetNotAdminUsers(int page, int number, UserOrderCriteria orderCriteria)
+        {
+            var users = userService.GetNotAdminUsers(page, number, orderCriteria).ToList();
+            if (users.Count == 0)
+            {
+                logger.LogError("[ERREUR] Aucun utilisateur trouvé.");
+                return StatusCode(204);
+            }
+
+            logger.LogInformation("[INFORMATION] {nb} Utilisateur(s) trouvé(s)", users.Count);
+            return Ok(users);
+        }
+        
+        [HttpGet("users/number")]
+        [ProducesResponseType(typeof(UserDto), 200)]
+        [ProducesResponseType(typeof(string), 204)]
+        public IActionResult GetNumberOfUsers()
+        {
+            var users = userService.GetNumberOfUsers();
+            if (users == 0)
+            {
+                logger.LogError("[ERREUR] Aucun utilisateur trouvé.");
+                return StatusCode(204);
+            }
+
+            logger.LogInformation("[INFORMATION] {users} Utilisateur(s) trouvé(s)", users);
+            return Ok(new KeyValuePair<string,int>("nbUsers", users));
+        }
+
         [HttpGet("user/{id:int}")]
         [ProducesResponseType(typeof(UserDto), 200)]
         [ProducesResponseType(typeof(string), 404)]
@@ -59,6 +91,22 @@ namespace API.Controllers
             catch (ArgumentException)
             {
                 logger.LogError("[ERREUR] Aucun utilisateur trouvé avec l'username {username}.", username);
+                return NotFound("Utilisateur non trouvé !");
+            }
+        }
+        [HttpGet("user/email/{email}")]
+        [ProducesResponseType(typeof(UserDto), 200)]
+        [ProducesResponseType(typeof(string), 404)]
+        public IActionResult GetByEmail(string email)
+        {
+            try
+            {
+                logger.LogInformation("[INFORMATION] Utilisateur avec l'username {email} a été trouvé.", email);
+                return Ok(userService.GetUserByEmail(email));
+            }
+            catch (ArgumentException)
+            {
+                logger.LogError("[ERREUR] Aucun utilisateur trouvé avec l'username {email}.", email);
                 return NotFound();
             }
         }
@@ -81,6 +129,24 @@ namespace API.Controllers
             }
         }
         
+        [HttpDelete("user/username/{username:alpha}")]
+        [ProducesResponseType(typeof(UserDto), 200)]
+        [ProducesResponseType(typeof(string), 404)]
+        public IActionResult DeleteUserByUsername(string username)
+        {
+            var success = userService.DeleteUserByUsername(username);
+            if (success)
+            {
+                logger.LogInformation("[INFORMATION] L'utilisateur avec le pseudo {username} a été supprimé.", username);
+                return Ok();
+            }
+            else
+            {
+                logger.LogError("[ERREUR] Aucun utilisateur trouvé avec le pseudo {username}.", username);
+                return NotFound();
+            }
+        }
+
         [HttpPost]
         [ProducesResponseType(typeof(UserDto), 201)]
         [ProducesResponseType(typeof(string), 400)]
@@ -91,6 +157,16 @@ namespace API.Controllers
                 return BadRequest();
             }
 
+            if (userService.IsEmailTaken(dto.Email))
+            {
+                return StatusCode(409, "Email déjà utilisé");
+            }
+
+            if (userService.IsUsernameTaken(dto.Username))
+            {
+                return StatusCode(410, "Username déjà utilisé");
+            }
+
             // return Ok(userService.CreateUser(username, password, email, isAdmin));
             logger.LogInformation(
                 "[INFORMATION] Un utilisateur a été créé : username - {username}, password - {password}, email - {email}, isAdmin - {isAdmin}",

API_SQLuedo/API/Program.cs

@@ -22,6 +22,9 @@ builder.Services.AddSwaggerGen();
 builder.Services.AddScoped<IUserService<UserEntity>, UserDataService>();
 builder.Services.AddScoped<IUserService<UserDto>, UserDataServiceApi>();
 
+builder.Services.AddScoped<IBlackListService<BlackListEntity>, BlackListDataService>();
+builder.Services.AddScoped<IBlackListService<BlackListDto>, BlackListDataServiceAPI>();
+
 builder.Services.AddScoped<IInquiryService<InquiryEntity>, InquiryDataService>();
 builder.Services.AddScoped<IInquiryService<InquiryDto>, InquiryDataServiceApi>();
 

API_SQLuedo/API/Service/BlackListDataServiceAPI.cs

@@ -0,0 +1,27 @@
+using Dto;
+using Entities;
+using Model.OrderCriteria;
+using Shared;
+using Shared.Mapper;
+
+namespace API.Service;
+
+public class BlackListDataServiceAPI (IBlackListService<BlackListEntity> userService) : IBlackListService<BlackListDto>
+{
+    public IEnumerable<BlackListDto> GetBannedUsers(int page, int number, BlackListOdrerCriteria orderCriteria) =>
+        userService.GetBannedUsers(page, number, orderCriteria).Select(b => b.FromEntityToDto());
+
+    public int GetNumberOfBannedUsers() => userService.GetNumberOfBannedUsers();
+    public BlackListDto? GetUserBannedByEmail(string email)
+    {
+        var res = userService.GetUserBannedByEmail(email);
+        if (res == null)
+        {
+            return null;
+        }
+        return res.FromEntityToDto();
+    }
+
+    public bool BanUser(string username) => userService.BanUser(username);
+    public bool UnbanUser(string email) => userService.UnbanUser(email);
+}

API_SQLuedo/API/Service/InquiryDataServiceAPI.cs

@@ -29,6 +29,11 @@ public class InquiryDataServiceApi(IInquiryService<InquiryEntity> inquiryService
         return inquiries.Select(i => i.FromEntityToDto()).ToList();
     }
 
+    public int GetNumberOfInquiries()
+    {
+        return inquiryService.GetNumberOfInquiries();
+    }
+
     public InquiryDto GetInquiryById(int id) => inquiryService.GetInquiryById(id).FromEntityToDto();
 
     public InquiryDto GetInquiryByTitle(string title) => inquiryService.GetInquiryByTitle(title).FromEntityToDto();

API_SQLuedo/API/Service/UserDataServiceAPI.cs

@@ -14,18 +14,35 @@ public class UserDataServiceApi(IUserService<UserEntity> userService) : IUserSer
         return usersEntities.Select(e => e.FromEntityToDto()).ToList();
     }
     
+    public IEnumerable<UserDto> GetNotAdminUsers(int page, int number, UserOrderCriteria orderCriteria)
+    {
+        var usersEntities = userService.GetNotAdminUsers(page, number, orderCriteria);
+        return usersEntities.Select(e => e.FromEntityToDto()).ToList();
+    }
+    
+    public int GetNumberOfUsers()
+    {
+        return userService.GetNumberOfUsers();
+    }
     public UserDto GetUserById(int id) => userService.GetUserById(id).FromEntityToDto();
 
     public UserDto GetUserByUsername(string username) => userService.GetUserByUsername(username).FromEntityToDto();
+    public UserDto GetUserByEmail(string email) => userService.GetUserByEmail(email).FromEntityToDto();
 
     public bool DeleteUser(int id) => userService.DeleteUser(id);
     
+    public bool DeleteUserByUsername(string username) => userService.DeleteUserByUsername(username);
+
     public UserDto UpdateUser(int id, UserDto user) =>
         userService.UpdateUser(id, user.FromDtoToEntity()).FromEntityToDto();
 
     public UserDto CreateUser(string username, string password, string email, bool isAdmin) =>
         userService.CreateUser(username, password, email, isAdmin).FromEntityToDto();
 
+    public bool IsEmailTaken(string email) => userService.IsEmailTaken(email);
+
+    public bool IsUsernameTaken(string username) => userService.IsUsernameTaken(username);
+
     public UserDto PromoteUser(int id) =>
         userService.PromoteUser(id).FromEntityToDto();
 }

API_SQLuedo/DbContextLib/UserDbContext.cs

@@ -23,12 +23,12 @@ namespace DbContextLib
 
         protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
         {
+            base.OnConfiguring(optionsBuilder);
             if (!optionsBuilder.IsConfigured)
             {
+                //optionsBuilder.UseNpgsql(Environment.GetEnvironmentVariable("CONNECTION_STRING", EnvironmentVariableTarget.Process));
                 optionsBuilder.UseNpgsql("Host=localhost;Database=SQLuedo;Username=admin;Password=motdepasse");
             }
-
-            base.OnConfiguring(optionsBuilder);
         }
 
         protected override void OnModelCreating(ModelBuilder builder)

API_SQLuedo/DbDataManager/Service/BlackListDataService.cs

@@ -0,0 +1,85 @@
+using DbContextLib;
+using Entities;
+using Microsoft.EntityFrameworkCore;
+using Model.OrderCriteria;
+using Shared;
+
+namespace DbDataManager.Service;
+
+public class BlackListDataService : IBlackListService<BlackListEntity>
+{
+    private UserDbContext DbContext { get; set; }
+
+    public BlackListDataService(UserDbContext context)
+    {
+        DbContext = context;
+        context.Database.EnsureCreated();
+    }
+    
+    public int GetNumberOfBannedUsers()
+    {
+        return DbContext.BlackLists.Count();
+    }
+    public IEnumerable<BlackListEntity> GetBannedUsers(int page, int number, BlackListOdrerCriteria orderCriteria)
+    {
+        if (page <= 0)
+        {
+            page = 1;
+        }
+
+        if (number <= 0)
+        {
+            number = 10;
+        }
+        IQueryable<BlackListEntity> query = DbContext.BlackLists.Skip((page - 1) * number).Take(number);
+        switch (orderCriteria)
+        {
+            case BlackListOdrerCriteria.None:
+                break;
+            case BlackListOdrerCriteria.ByEmail:
+                query = query.OrderBy(s => s.Email);
+                break;
+            case BlackListOdrerCriteria.ByExpirationDate:
+                query = query.OrderBy(s => s.ExpirationDate);
+                break;
+            default:
+                break;
+        }
+
+        var blackList = query.ToList();
+        return blackList;
+    }
+    public BlackListEntity? GetUserBannedByEmail(string email)
+    {
+        var blackListEntity = DbContext.BlackLists.FirstOrDefault(b => b.Email == email);
+        return blackListEntity;
+    }
+
+    public bool BanUser(string username)
+    {
+        var userEntity = DbContext.Users.FirstOrDefault(u => u.Username == username);
+        if (userEntity == null)
+        {
+            return false;
+        }
+
+        DbContext.BlackLists.Add(new BlackListEntity
+            { Email = userEntity.Email, ExpirationDate = DateOnly.FromDateTime(DateTime.Now.AddYears(2)) });
+        DbContext.Users.Remove(userEntity);
+        DbContext.SaveChangesAsync();
+        return true;
+    }
+    
+    public bool UnbanUser(string email)
+    {
+        var blackListEntity = DbContext.BlackLists.FirstOrDefault(b => b.Email == email);
+        if (blackListEntity == null)
+        {
+            return false;
+        }
+
+        DbContext.BlackLists.Remove(blackListEntity);
+        DbContext.SaveChangesAsync();
+        return true;
+    }
+}

API_SQLuedo/DbDataManager/Service/InquiryDataService.cs

@@ -48,6 +48,11 @@ public class InquiryDataService : IInquiryService<InquiryEntity>
         return inquiries;
     }
 
+    public int GetNumberOfInquiries()
+    {
+        return DbContext.Inquiries.Count();
+    }
+
     public InquiryEntity GetInquiryById(int id)
     {
         var inquiryEntity = DbContext.Inquiries.FirstOrDefault(i => i.Id == id);

API_SQLuedo/DbDataManager/Service/LessonDataService.cs

@@ -23,10 +23,12 @@ public class LessonDataService : ILessonService<LessonEntity>
         {
             page = 1;
         }
+
         if (number <= 0)
         {
             number = 10;
         }
+
         IQueryable<LessonEntity> query = DbContext.Lessons.Skip((page - 1) * number).Take(number);
         switch (orderCriteria)
         {
@@ -73,64 +75,41 @@ public class LessonDataService : ILessonService<LessonEntity>
 
     public bool DeleteLesson(int id)
     {
-        using (UserDbContext context = new UserDbContext(new DbContextOptions<UserDbContext>()))
+        var lessonEntity = DbContext.Lessons.FirstOrDefault(l => l.Id == id);
-        {
-            var lessonEntity = context.Lessons.FirstOrDefault(l => l.Id == id);
         if (lessonEntity == null)
-            {
             return false;
-            }
 
-            context.Lessons.Remove(lessonEntity);
+        DbContext.Lessons.Remove(lessonEntity);
-            context.SaveChangesAsync();
+        DbContext.SaveChanges();
         return true;
     }
-    }
 
     public LessonEntity UpdateLesson(int id, LessonEntity lesson)
     {
-        using (UserDbContext context = new UserDbContext(new DbContextOptions<UserDbContext>()))
+        var updatingLesson = DbContext.Lessons.FirstOrDefault(l => l.Id == id);
-        {
-            var updatingLesson = context.Lessons.FirstOrDefault(l => l.Id == id);
         if (updatingLesson == null)
-            {
             throw new ArgumentException("Impossible de trouver la leçon", nameof(id));
-            }
 
-            foreach (var pptt in typeof(LessonEntity).GetProperties()
+        updatingLesson.Title = lesson.Title;
-                         .Where(p => p.CanWrite && p.Name != nameof(LessonEntity.Id)))
+        updatingLesson.LastPublisher = lesson.LastPublisher;
-            {
+        updatingLesson.LastEdit = lesson.LastEdit;
-                pptt.SetValue(updatingLesson, pptt.GetValue(lesson));
-            }
 
-            context.SaveChangesAsync();
+        DbContext.SaveChanges();
         return updatingLesson;
     }
-    }
+
     public LessonEntity CreateLesson(int id, string title, string lastPublisher, DateOnly lastEdit)
     {
-        using (UserDbContext context = new UserDbContext(new DbContextOptions<UserDbContext>()))
-        {
-            DateTime date = DateTime.Now;
         var newLessonEntity = new LessonEntity()
         {
+            Id = id > 0 && DbContext.Lessons.All(l => l.Id != id) ? id : 0,
             Title = title,
             LastPublisher = lastPublisher,
             LastEdit = lastEdit,
         };
-            var lesson = context.Lessons.FirstOrDefault(l => l.Id == id);
-            if (lesson == null && id > 0)
-            {
-                newLessonEntity.Id = id;
-                context.Lessons.Add(newLessonEntity);
-                context.SaveChangesAsync();
-                throw new ArgumentException(
-                    $"Erreur, l'ID {id} est déjà utilisé pour une autre leçon, un id par a été attribué.");
-            }
 
-            context.Lessons.Add(newLessonEntity);
+        DbContext.Lessons.Add(newLessonEntity);
-            context.SaveChangesAsync();
+        DbContext.SaveChanges();
         return newLessonEntity;
     }
-    }
 }

API_SQLuedo/DbDataManager/Service/ParagraphDataService.cs

@@ -85,7 +85,7 @@ public class ParagraphDataService : IParagraphService<ParagraphEntity>
         }
 
         DbContext.Paragraphs.Remove(paragraphEntity);
-        DbContext.SaveChangesAsync();
+        DbContext.SaveChanges();
         return true;
     }
 

API_SQLuedo/DbDataManager/Service/UserDataService.cs

@@ -37,6 +37,17 @@ public class UserDataService : IUserService<UserEntity>
         return userEntity;
     }
 
+    public UserEntity GetUserByEmail(string email)
+    {
+        var userEntity = DbContext.Users.FirstOrDefault(u => u.Email == email);
+        if (userEntity == null)
+        {
+            throw new ArgumentException("Impossible de trouver l'utilisateur", nameof(email));
+        }
+
+        return userEntity;
+    }
+
     public IEnumerable<UserEntity> GetUsers(int page, int number, UserOrderCriteria orderCriteria)
     {
         if (page <= 0)
@@ -72,6 +83,45 @@ public class UserDataService : IUserService<UserEntity>
         return users;
     }
 
+    public IEnumerable<UserEntity> GetNotAdminUsers(int page, int number, UserOrderCriteria orderCriteria)
+    {
+        if (page <= 0)
+        {
+            page = 1;
+        }
+        if (number <= 0)
+        {
+            number = 10;
+        }
+        IQueryable<UserEntity> query = DbContext.Users.Where(u => u.IsAdmin == false).Skip((page - 1) * number).Take(number);
+        switch (orderCriteria)
+        {
+            case UserOrderCriteria.None:
+                break;
+            case UserOrderCriteria.ById:
+                query = query.OrderBy(s => s.Id);
+                break;
+            case UserOrderCriteria.ByUsername:
+                query = query.OrderBy(s => s.Username);
+                break;
+            case UserOrderCriteria.ByEmail:
+                query = query.OrderBy(s => s.Email);
+                break;
+            case UserOrderCriteria.ByIsAdmin:
+                query = query.OrderBy(s => s.IsAdmin);
+                break;
+            default:
+                break;
+        }
+
+        var users = query.ToList();
+        return users;
+    }
+    public int GetNumberOfUsers()
+    {
+        return DbContext.Users.Count();
+    }
+
     public bool DeleteUser(int id)
     {
         var userEntity = DbContext.Users.FirstOrDefault(u => u.Id == id);
@@ -85,6 +135,18 @@ public class UserDataService : IUserService<UserEntity>
         return true;
     }
 
+    public bool DeleteUserByUsername(string username)
+    {
+        var userEntity = DbContext.Users.FirstOrDefault(u => u.Username == username);
+        if (userEntity == null)
+        {
+            return false;
+        }
+        DbContext.Users.Remove(userEntity);
+        DbContext.SaveChangesAsync();
+        return true;
+    }
+
     public UserEntity UpdateUser(int id, UserEntity user)
     {
         var updatingUser = DbContext.Users.FirstOrDefault(u => u.Id == id);
@@ -117,6 +179,18 @@ public class UserDataService : IUserService<UserEntity>
         return newUserEntity;
     }
 
+    public bool IsEmailTaken(string email)
+    {
+        var isEmail = DbContext.Users.Any(u => u.Email == email);
+        return isEmail;
+    }
+
+    public bool IsUsernameTaken(string username)
+    {
+        var isUsername = DbContext.Users.Any(u => u.Username == username);
+        return isUsername;
+    }
+
     public UserEntity PromoteUser(int id)
     {
         var userEdit = GetUserById(id);

API_SQLuedo/Dto/UserDTO.cs

@@ -34,7 +34,12 @@
             return $"{Id}\t{Username}\t{Email}\t{IsAdmin}";
         }
 
-        public override bool Equals(object obj)
+        public bool Equals(UserDto? other)
+        {
+            return (this.Id == other?.Id);
+        }
+
+        public override bool Equals(object? obj)
         {
             if (object.ReferenceEquals(obj, null))
             {
@@ -54,11 +59,6 @@
             return this.Equals(obj as UserDto);
         }
 
-        public bool Equals(UserDto other)
-        {
-            return (this.Id == other.Id);
-        }
-
         public override int GetHashCode()
         {
             return Id;

API_SQLuedo/EntityFramework/UserEntity.cs

@@ -1,8 +1,11 @@
 using System.ComponentModel.DataAnnotations.Schema;
+using Microsoft.EntityFrameworkCore;
 
 namespace Entities;
 
 [Table("User")]
+[Index(nameof(Username), IsUnique = true)]
+[Index(nameof(Email), IsUnique = true)]
 public class UserEntity
 {
     public int Id { get; set; }

API_SQLuedo/Model/OrderCriteria/BlackListOdrerCriteria.cs

@@ -0,0 +1,6 @@
+namespace Model.OrderCriteria;
+
+public enum BlackListOdrerCriteria
+{
+    None, ByEmail, ByExpirationDate
+}

API_SQLuedo/Model/Solution.cs

@@ -7,30 +7,30 @@ public class Solution
     public string MurdererLastName { get; set; }
     public string MurderPlace { get; set; }
     public string MurderWeapon { get; set; }
-    public string Explanation { get; set; }
+    public string Explaination { get; set; }
 
     public Solution()
     {
     }
 
     public Solution(int ownerId, string murdererFirstName, string murdererLastName, string murderPlace,
-        string murderWeapon, string explanation)
+        string murderWeapon, string explaination)
     {
         OwnerId = ownerId;
         MurdererFirstName = murdererFirstName;
         MurdererLastName = murdererLastName;
         MurderPlace = murderPlace;
         MurderWeapon = murderWeapon;
-        Explanation = explanation;
+        Explaination = explaination;
     }
 
     public Solution(string murdererFirstName, string murdererLastName, string murderPlace, string murderWeapon,
-        string explanation)
+        string explaination)
     {
         MurdererFirstName = murdererFirstName;
         MurdererLastName = murdererLastName;
         MurderPlace = murderPlace;
         MurderWeapon = murderWeapon;
-        Explanation = explanation;
+        Explaination = explaination;
     }
 }

API_SQLuedo/Shared/IBlackListService.cs

@@ -0,0 +1,12 @@
+using Model.OrderCriteria;
+
+namespace Shared;
+
+public interface IBlackListService<TBlackList>
+{
+    public IEnumerable<TBlackList> GetBannedUsers(int page, int number, BlackListOdrerCriteria orderCriteria);
+    public int GetNumberOfBannedUsers();
+    public TBlackList? GetUserBannedByEmail(string email);
+    public bool BanUser(string username);
+    public bool UnbanUser(string email);
+}

API_SQLuedo/Shared/IInquiryService.cs

@@ -5,6 +5,7 @@ namespace Shared;
 public interface IInquiryService<TInquiry>
 {
     public IEnumerable<TInquiry> GetInquiries(int page, int number, InquiryOrderCriteria orderCriteria);
+    public int GetNumberOfInquiries();
     public TInquiry GetInquiryById(int id);
     public TInquiry GetInquiryByTitle(string title);
     public bool DeleteInquiry(int id);

API_SQLuedo/Shared/IUserService.cs

@@ -5,11 +5,17 @@ namespace Shared
     public interface IUserService<TUser>
     {
         public IEnumerable<TUser> GetUsers(int page, int number, UserOrderCriteria orderCriteria);
+        public IEnumerable<TUser> GetNotAdminUsers(int page, int number, UserOrderCriteria orderCriteria);
+        public int GetNumberOfUsers();
         public TUser GetUserById(int id);
         public TUser GetUserByUsername(string username);
+        public TUser GetUserByEmail(string email);
         public bool DeleteUser(int id);
+        public bool DeleteUserByUsername(string username);
         public TUser UpdateUser(int id, TUser user);
         public TUser CreateUser(string username, string password, string email, bool isAdmin);
+        public bool IsEmailTaken(string email);
+        public bool IsUsernameTaken(string username);
         public TUser PromoteUser(int id);
     }
 }

API_SQLuedo/Shared/Mapper/SolutionMapper.cs

@@ -21,7 +21,7 @@ public static class SolutionMapper
     public static SolutionDto FromModelToDto(this Solution model)
     {
         return new SolutionDto(model.OwnerId, model.MurdererFirstName, model.MurdererLastName, model.MurderPlace,
-            model.MurderWeapon, model.Explanation);
+            model.MurderWeapon, model.Explaination);
     }
 
     public static SolutionDto FromEntityToDto(this SolutionEntity entity)
@@ -43,7 +43,7 @@ public static class SolutionMapper
             MurdererLastName = model.MurdererLastName,
             MurderPlace = model.MurderPlace,
             MurderWeapon = model.MurderWeapon,
-            Explaination = model.Explanation
+            Explaination = model.Explaination
         };
     }
 

API_SQLuedo/StubbedContextLib/StubbedContext.cs

@@ -1,5 +1,6 @@
 using System.Security.Cryptography;
 using DbContextLib;
+using DevOne.Security.Cryptography.BCrypt;
 using Entities;
 using Microsoft.AspNetCore.Cryptography.KeyDerivation;
 using Microsoft.EntityFrameworkCore;
@@ -20,12 +21,13 @@ public class StubbedContext : UserDbContext
             {
                 Id = 1,
                 Username = "johnny",
-                Password = Convert.ToBase64String(KeyDerivation.Pbkdf2(
+                /*Password = Convert.ToBase64String(KeyDerivation.Pbkdf2(
-                    password: "motdepasse",
+                    password: "Motdepasse",
                     salt: RandomNumberGenerator.GetBytes(128 / 8),
                     prf: KeyDerivationPrf.HMACSHA256,
                     iterationCount: 100000,
-                    numBytesRequested: 256 / 8)),
+                    numBytesRequested: 256 / 8)),*/
+                Password = BCryptHelper.HashPassword("Motdepasse", BCryptHelper.GenerateSalt()),
                 Email = "Johnny.RATTON@etu.uca.fr",
                 IsAdmin = true
             },
@@ -33,12 +35,13 @@ public class StubbedContext : UserDbContext
             {
                 Id = 2,
                 Username = "maxime",
-                Password = Convert.ToBase64String(KeyDerivation.Pbkdf2(
+                /*Password = Convert.ToBase64String(KeyDerivation.Pbkdf2(
-                    password: "motdepasse",
+                    password: "Motdepasse",
                     salt: RandomNumberGenerator.GetBytes(128 / 8),
                     prf: KeyDerivationPrf.HMACSHA256,
                     iterationCount: 100000,
-                    numBytesRequested: 256 / 8)),
+                    numBytesRequested: 256 / 8)),*/
+                Password = BCryptHelper.HashPassword("Motdepasse", BCryptHelper.GenerateSalt()),
                 Email = "Maxime.SAPOUNTZIS@etu.uca.fr",
                 IsAdmin = true
             },
@@ -46,12 +49,13 @@ public class StubbedContext : UserDbContext
             {
                 Id = 3,
                 Username = "clement",
-                Password = Convert.ToBase64String(KeyDerivation.Pbkdf2(
+                /*Password = Convert.ToBase64String(KeyDerivation.Pbkdf2(
-                    password: "motdepasse",
+                    password: "Motdepasse",
                     salt: RandomNumberGenerator.GetBytes(128 / 8),
                     prf: KeyDerivationPrf.HMACSHA256,
                     iterationCount: 100000,
-                    numBytesRequested: 256 / 8)),
+                    numBytesRequested: 256 / 8)),*/
+                Password = BCryptHelper.HashPassword("Motdepasse", BCryptHelper.GenerateSalt()),
                 Email = "Clement.CHIEU@etu.uca.fr",
                 IsAdmin = true
             },
@@ -59,12 +63,13 @@ public class StubbedContext : UserDbContext
             {
                 Id = 4,
                 Username = "erwan",
-                Password = Convert.ToBase64String(KeyDerivation.Pbkdf2(
+                /*Password = Convert.ToBase64String(KeyDerivation.Pbkdf2(
-                    password: "motdepasse",
+                    password: "Motdepasse",
                     salt: RandomNumberGenerator.GetBytes(128 / 8),
                     prf: KeyDerivationPrf.HMACSHA256,
                     iterationCount: 100000,
-                    numBytesRequested: 256 / 8)),
+                    numBytesRequested: 256 / 8)),*/
+                Password = BCryptHelper.HashPassword("Motdepasse", BCryptHelper.GenerateSalt()),
                 Email = "Erwan.MENAGER@etu.uca.fr",
                 IsAdmin = true
             },
@@ -72,12 +77,13 @@ public class StubbedContext : UserDbContext
             {
                 Id = 5,
                 Username = "victor",
-                Password = Convert.ToBase64String(KeyDerivation.Pbkdf2(
+                /*Password = Convert.ToBase64String(KeyDerivation.Pbkdf2(
-                    password: "motdepasse",
+                    password: "Motdepasse",
                     salt: RandomNumberGenerator.GetBytes(128 / 8),
                     prf: KeyDerivationPrf.HMACSHA256,
                     iterationCount: 100000,
-                    numBytesRequested: 256 / 8)),
+                    numBytesRequested: 256 / 8)),*/
+                Password = BCryptHelper.HashPassword("Motdepasse", BCryptHelper.GenerateSalt()),
                 Email = "Victor.GABORIT@etu.uca.fr",
                 IsAdmin = true
             });

API_SQLuedo/StubbedContextLib/StubbedContextLib.csproj

@@ -11,6 +11,7 @@
     </ItemGroup>
 
     <ItemGroup>
+      <PackageReference Include="BCrypt" Version="1.0.0" />
       <PackageReference Include="Microsoft.EntityFrameworkCore.Design" Version="8.0.2">
         <PrivateAssets>all</PrivateAssets>
         <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>

API_SQLuedo/TestAPI/BlackListUnitTest.cs

@@ -0,0 +1,178 @@
+using API.Controllers;
+using Dto;
+using Entities;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.Extensions.Logging.Abstractions;
+using Model.OrderCriteria;
+using Moq;
+using Shared;
+using TestAPI.Extensions;
+
+namespace TestAPI;
+
+public class BlackListUnitTest
+{
+    private readonly Mock<IBlackListService<BlackListDto>> _blackListService;
+
+    public BlackListUnitTest()
+    {
+        _blackListService = new Mock<IBlackListService<BlackListDto>>();
+    }
+    [Fact]
+    public void IsBanned()
+    {
+        _blackListService.Setup(x => x.GetUserBannedByEmail("email@example.com"))
+            .Returns(new BlackListDto { Email = "email@example.com", ExpirationDate = DateOnly.FromDateTime(DateTime.Now)});
+        var usersController = new BlackListController(new NullLogger<UsersController>(), _blackListService.Object);
+        var result = usersController.GetUserBannedByEmail("email@example.com");
+        Assert.Equal(typeof(OkObjectResult), result.GetType());
+    }
+    
+    [Fact]
+    public void IsBannedNotFound()
+    {
+        _blackListService.Setup(x => x.GetUserBannedByEmail("example@notfound.com"))
+            .Returns<BlackListDto?>(null);
+        var usersController = new BlackListController(new NullLogger<UsersController>(), _blackListService.Object);
+        var result = usersController.GetUserBannedByEmail("example@notfound.com");
+        Assert.Equal(typeof(NotFoundObjectResult), result.GetType());
+    }
+    
+    [Fact]
+    public void BanUser()
+    {
+        _blackListService.Setup(x => x.BanUser("Test1"))
+            .Returns(true);
+        var usersController = new BlackListController(new NullLogger<UsersController>(), _blackListService.Object);
+
+        var userResult = usersController.BanUser("Test1");
+        Assert.Equal(typeof(OkObjectResult), userResult.GetType());
+    }
+    
+    [Fact]
+    public void BanUserNotFound()
+    {
+        _blackListService.Setup(x => x.BanUser("Test1"))
+            .Returns(true);
+        var usersController = new BlackListController(new NullLogger<UsersController>(), _blackListService.Object);
+
+        var userResult = usersController.BanUser("Test42");
+        Assert.Equal(typeof(NotFoundResult), userResult.GetType());
+    }
+    
+    [Fact]
+    public void UnbanUser()
+    {
+        _blackListService.Setup(x => x.UnbanUser("example@email.com"))
+            .Returns(true);
+        var usersController = new BlackListController(new NullLogger<UsersController>(), _blackListService.Object);
+
+        var userResult = usersController.UnbanUser("example@email.com");
+        Assert.Equal(typeof(OkObjectResult), userResult.GetType());
+    }
+    
+    [Fact]
+    public void UnbanUserNotFound()
+    {
+        _blackListService.Setup(x => x.UnbanUser("example@email.com"))
+            .Returns(false);
+        var usersController = new BlackListController(new NullLogger<UsersController>(), _blackListService.Object);
+
+        var userResult = usersController.UnbanUser("example@email.com");
+        Assert.Equal(typeof(NotFoundResult), userResult.GetType());
+    }
+    
+    [Fact]
+    public void GetBannedUsers_NoneOrderCriteria()
+    {
+        _blackListService.Setup(x => x.GetBannedUsers(1,10,BlackListOdrerCriteria.None))
+            .Returns(new List<BlackListDto>()
+            {
+                new BlackListDto { Email = "example1@email.com" , ExpirationDate = DateOnly.FromDateTime(DateTime.Now) },
+                new BlackListDto { Email = "example2@email.com" , ExpirationDate = DateOnly.FromDateTime(DateTime.Now) },
+                new BlackListDto { Email = "example3@email.com" , ExpirationDate = DateOnly.FromDateTime(DateTime.Now) }
+            });
+        var blackListController = new BlackListController(new NullLogger<UsersController>(), _blackListService.Object);
+
+        var result = blackListController.GetBannedUsers(1,10,BlackListOdrerCriteria.None);
+        Assert.Equal(typeof(OkObjectResult), result.GetType());
+        if (result is OkObjectResult okObjectResult)
+        {
+            var valeur = okObjectResult.Value;
+
+            Assert.NotNull(valeur);
+            Assert.Equal(GetBlackList().ToString(), valeur.ToString());
+            Assert.True(GetBlackList().SequenceEqual(valeur as IEnumerable<BlackListDto>, new BlackListDtoEqualityComparer()));
+        }
+    }
+    
+    [Fact]
+    public void GetBannedUsers_OrderByEmail()
+    {
+        _blackListService.Setup(x => x.GetBannedUsers(1,10,BlackListOdrerCriteria.ByEmail))
+            .Returns(new List<BlackListDto>()
+            {
+                new BlackListDto { Email = "example1@email.com" , ExpirationDate = DateOnly.FromDateTime(DateTime.Now) },
+                new BlackListDto { Email = "example2@email.com" , ExpirationDate = DateOnly.FromDateTime(DateTime.Now) },
+                new BlackListDto { Email = "example3@email.com" , ExpirationDate = DateOnly.FromDateTime(DateTime.Now) }
+            });
+        var blackListController = new BlackListController(new NullLogger<UsersController>(), _blackListService.Object);
+
+        var result = blackListController.GetBannedUsers(1,10,BlackListOdrerCriteria.ByEmail);
+        Assert.Equal(typeof(OkObjectResult), result.GetType());
+        if (result is OkObjectResult okObjectResult)
+        {
+            var valeur = okObjectResult.Value;
+
+            Assert.NotNull(valeur);
+            Assert.Equal(GetBlackList().ToString(), valeur.ToString());
+            Assert.True(GetBlackList().SequenceEqual(valeur as IEnumerable<BlackListDto>, new BlackListDtoEqualityComparer()));
+        }
+    }
+    
+    [Fact]
+    public void GetBannedUsers_OrderedByExpirationDate()
+    {
+        _blackListService.Setup(x => x.GetBannedUsers(1,10,BlackListOdrerCriteria.ByExpirationDate))
+            .Returns(new List<BlackListDto>()
+            {
+                new BlackListDto { Email = "example1@email.com" , ExpirationDate = DateOnly.FromDateTime(DateTime.Now) },
+                new BlackListDto { Email = "example2@email.com" , ExpirationDate = DateOnly.FromDateTime(DateTime.Now) },
+                new BlackListDto { Email = "example3@email.com" , ExpirationDate = DateOnly.FromDateTime(DateTime.Now) }
+            });
+        var blackListController = new BlackListController(new NullLogger<UsersController>(), _blackListService.Object);
+
+        var result = blackListController.GetBannedUsers(1,10,BlackListOdrerCriteria.ByExpirationDate);
+        Assert.Equal(typeof(OkObjectResult), result.GetType());
+        if (result is OkObjectResult okObjectResult)
+        {
+            var valeur = okObjectResult.Value;
+
+            Assert.NotNull(valeur);
+            Assert.Equal(GetBlackList().ToString(), valeur.ToString());
+            Assert.True(GetBlackList().SequenceEqual(valeur as IEnumerable<BlackListDto>, new BlackListDtoEqualityComparer()));
+        }
+    }
+    
+    [Fact]
+    public void GetNbBannedUsers()
+    {
+        _blackListService.Setup(x => x.GetNumberOfBannedUsers())
+            .Returns(10);
+        var usersController = new BlackListController(new NullLogger<UsersController>(), _blackListService.Object);
+
+        var userResult = usersController.GetNumberOfBannedUsers();
+        Assert.Equal(typeof(OkObjectResult), userResult.GetType());
+        Assert.Equal(10, ((KeyValuePair<string,int>)(userResult as OkObjectResult).Value).Value);
+    }
+
+    private IEnumerable<BlackListDto> GetBlackList()
+    {
+        return new List<BlackListDto>()
+        {
+            new BlackListDto { Email = "example1@email.com" , ExpirationDate = DateOnly.FromDateTime(DateTime.Now) },
+            new BlackListDto { Email = "example2@email.com" , ExpirationDate = DateOnly.FromDateTime(DateTime.Now) },
+            new BlackListDto { Email = "example3@email.com" , ExpirationDate = DateOnly.FromDateTime(DateTime.Now) }
+        };
+    }
+}

API_SQLuedo/TestAPI/Extensions/BlackListDto.EqualityComparer.cs

@@ -0,0 +1,16 @@
+using Dto;
+
+namespace TestAPI.Extensions;
+
+public class BlackListDtoEqualityComparer : EqualityComparer<BlackListDto>
+{
+    public override bool Equals(BlackListDto x, BlackListDto y)
+    {
+        return x.Email == y.Email;
+    }
+
+    public override int GetHashCode(BlackListDto obj)
+    {
+        return obj.Email.GetHashCode();
+    }
+}

API_SQLuedo/TestAPI/InquiryUnitTest.cs

@@ -37,6 +37,25 @@ public class InquiryUnitTest
         }
     }
     
+    [Fact]
+    public void GetNumberOfInquiries()
+    {
+        var inquiryList = GetInquiriesData();
+        _inquiryService.Setup(x => x.GetNumberOfInquiries())
+            .Returns(4);
+        var inquiryController = new InquiriesController(_inquiryService.Object, new NullLogger<InquiriesController>());
+
+        var inquiriesResult = inquiryController.GetNumberOfInquiries();
+
+        if (inquiriesResult is OkObjectResult okObjectResult)
+        {
+            var valeur = (KeyValuePair<string,int>)okObjectResult.Value;
+
+            Assert.NotNull(valeur);
+            Assert.Equal(GetInquiriesData().Count, valeur.Value);
+        }
+    }
+
     [Fact]
     public void GetInquiresListFail()
     {

API_SQLuedo/TestAPI/UserUnitTest.cs

@@ -18,7 +18,25 @@ public class UserUnitTest
     }
 
     [Fact]
-    public void GetUserListSuccess()
+    public void GetNumberOfUsers()
+    {
+        var userList = GetUsersData();
+        _userService.Setup(x => x.GetNumberOfUsers())
+            .Returns(userList.Count);
+        var usersController = new UsersController(new NullLogger<UsersController>(), _userService.Object);
+
+        var userResult = usersController.GetNumberOfUsers();
+
+        if (userResult is OkObjectResult okObjectResult)
+        {
+            var valeur = (okObjectResult.Value as KeyValuePair<string,int>?);
+            Assert.NotNull(valeur);
+            Assert.Equal(userList.Count, valeur.Value.Value);
+        }
+    }
+    
+    [Fact]
+    public void GetUsersListSuccess()
     {
         var userList = GetUsersData();
         _userService.Setup(x => x.GetUsers(1, 4, 0))
@@ -37,6 +55,26 @@ public class UserUnitTest
         }
     }
     
+    [Fact]
+    public void GetNotAdminUsersListSuccess()
+    {
+        var userList = GetUsersData();
+        _userService.Setup(x => x.GetNotAdminUsers(1, 4, 0))
+            .Returns(userList.Where(u => u.IsAdmin == false));
+        var usersController = new UsersController(new NullLogger<UsersController>(), _userService.Object);
+
+        var userResult = usersController.GetNotAdminUsers(1, 4, 0);
+
+        if (userResult is OkObjectResult okObjectResult)
+        {
+            var valeur = okObjectResult.Value;
+
+            Assert.NotNull(valeur);
+            Assert.Equal(GetUsersData().ToString(), valeur.ToString());
+            Assert.True(userList.Where(u => u.IsAdmin == false).SequenceEqual(valeur as IEnumerable<UserDto>, new UserIdEqualityComparer()));
+        }
+    }
+
     [Fact]
     public void GetUserListFail()
     {
@@ -117,6 +155,28 @@ public class UserUnitTest
             Assert.True(valeur.IsAdmin);
         }
     }
+    [Fact]
+    public void GetUserEmailSuccess()
+    {
+        var userList = GetUsersData();
+        _userService.Setup(x => x.GetUserByEmail("adressemail@gmail.com"))
+            .Returns(userList[0]);
+        var usersController = new UsersController(new NullLogger<UsersController>(), _userService.Object);
+
+        var userResult = usersController.GetByEmail("adressemail@gmail.com");
+        if (userResult is OkObjectResult okObjectResult)
+        {
+            UserDto valeur = okObjectResult.Value as UserDto;
+
+            Assert.NotNull(valeur);
+            Assert.IsType<UserDto>(valeur);
+            Assert.Contains(valeur, userList);
+            Assert.Equal("adressemail@gmail.com", valeur.Email);
+            Assert.Equal("Useruser", valeur.Username);
+            Assert.Equal("motdepasse", valeur.Password);
+            Assert.True(valeur.IsAdmin);
+        }
+    }
 
     [Fact]
     public void GetUserUsernameFail()
@@ -138,6 +198,26 @@ public class UserUnitTest
             Assert.False(userList == valeur);
         }
     }
+    [Fact]
+    public void GetUserEmailFail()
+    {
+        var userList = GetUsersData();
+        _userService.Setup(x => x.GetUserByEmail("adressemail@gmail.com"))
+            .Returns(userList[0]);
+        var usersController = new UsersController(new NullLogger<UsersController>(), _userService.Object);
+
+        var userResult = usersController.GetByEmail("GYIIieihhh");
+
+        if (userResult is NotFoundObjectResult nfObjectResult)
+        {
+            var valeur = nfObjectResult.Value;
+
+            Assert.NotNull(valeur);
+            Assert.IsNotType<UserDto>(valeur);
+            Assert.DoesNotContain(valeur, userList);
+            Assert.False(userList == valeur);
+        }
+    }
 
     [Fact]
     public void DeleteUserSuccess()
@@ -205,6 +285,36 @@ public class UserUnitTest
             Assert.Equal(400, bdObjectResult.StatusCode);
         }
     }
+    [Fact]
+    public void CreateUserWithExistingEmail()
+    {
+        GetUsersData();
+        _userService.Setup(x => x.CreateUser("Nom", "Passssss", "adressemail@gmail.com", true))
+            .Returns(new UserDto("Nom", "Passssss", "adressemail@gmail.com", true));
+        var usersController = new UsersController(new NullLogger<UsersController>(), _userService.Object);
+
+        var userResult = usersController.CreateUser(new UserDto(null, "Passssss", "adressemail@gmail.com", true));
+
+        if (userResult is BadRequestResult bdObjectResult)
+        {
+            Assert.Equal(400, bdObjectResult.StatusCode);
+        }
+    }
+    [Fact]
+    public void CreateUserWithExistingUsername()
+    {
+        GetUsersData();
+        _userService.Setup(x => x.CreateUser("Useruser", "Passssss", "heudfk@hdye.com", true))
+            .Returns(new UserDto("Useruser", "Passssss", "heudfk@hdye.com", true));
+        var usersController = new UsersController(new NullLogger<UsersController>(), _userService.Object);
+
+        var userResult = usersController.CreateUser(new UserDto("Useruser", "Passssss", "heudfk@hdye.com", true));
+
+        if (userResult is BadRequestResult bdObjectResult)
+        {
+            Assert.Equal(400, bdObjectResult.StatusCode);
+        }
+    }
 
     [Fact]
     public void UpdateUserSuccess()

API_SQLuedo/TestEF/Dto/TestUserDTO.cs

@@ -42,5 +42,48 @@ namespace TestEF.Dto
             Assert.Equal(Password, user.Password);
             Assert.True(user.IsAdmin);
         }
+        
+        [Fact]
+        public void TestToString()
+        {
+            UserDto user = new UserDto(Id, Username, Password, Email, IsAdmin);
+            Assert.Equal($"{Id}\t{Username}\t{Email}\t{IsAdmin}", user.ToString());
+        }
+        
+        [Fact]
+        public void TestEqualsWithSameAttributesValues()
+        {
+            UserDto user1 = new UserDto(Id, Username, Password, Email, IsAdmin);
+            UserDto user2 = new UserDto(Id, Username, Password, Email, IsAdmin);
+            Assert.True(user1.Equals(user2));
+        }
+        
+        [Fact]
+        public void TestEqualsWithNullReference()
+        {
+            UserDto user = new UserDto(Id, Username, Password, Email, IsAdmin);
+            Assert.False(user.Equals(null));
+        }
+        
+        [Fact]
+        public void TestEqualsWithSameReference()
+        {
+            UserDto user = new UserDto(Id, Username, Password, Email, IsAdmin);
+            Assert.True(user.Equals(user));
+        }
+        
+        [Fact]
+        public void TestEqualsWithDifferentType()
+        {
+            UserDto user = new UserDto(Id, Username, Password, Email, IsAdmin);
+            Assert.False(user.Equals("Tests"));
+        }
+        
+        [Fact]
+        public void TestGetHashCode()
+        {
+            UserDto user = new UserDto(Id, Username, Password, Email, IsAdmin);
+            Assert.Equal(Id, user.GetHashCode());
+        }
     }
 }

API_SQLuedo/TestEF/Mapper/SolutionMapperUnitTest.cs

@@ -52,7 +52,7 @@ namespace TestEF.Mapper
             Assert.Equal(_murdererLastName, solutionMod.MurdererLastName);
             Assert.Equal(_murderPlace, solutionMod.MurderPlace);
             Assert.Equal(_murderWeapon, solutionMod.MurderWeapon);
-            Assert.Equal(_explanation, solutionMod.Explanation);
+            Assert.Equal(_explanation, solutionMod.Explaination);
 
         }
 
@@ -85,7 +85,7 @@ namespace TestEF.Mapper
             Assert.Equal(_murdererLastName, solutionMod.MurdererLastName);
             Assert.Equal(_murderPlace, solutionMod.MurderPlace);
             Assert.Equal(_murderWeapon, solutionMod.MurderWeapon);
-            Assert.Equal(_explanation, solutionMod.Explanation);
+            Assert.Equal(_explanation, solutionMod.Explaination);
         }
 
 

API_SQLuedo/TestEF/Model/BlackListTest.cs

@@ -0,0 +1,32 @@
+using Model;
+
+namespace TestEF.Model;
+
+public class BlackListTest
+{
+    [Fact]
+    void TestConstructorWithRightParameters()
+    {
+        BlackList blackList = new BlackList("example@email.com", DateOnly.FromDateTime(DateTime.Now));
+        Assert.Equal("example@email.com", blackList.Email);
+        Assert.Equal(DateOnly.FromDateTime(DateTime.Now), blackList.ExpirationDate);
+    }
+    
+    [Fact]
+    void TestConstructorWithNullEmail()
+    {
+        Assert.Throws<ArgumentException>(() =>
+        {
+            BlackList blackList = new BlackList(null, DateOnly.FromDateTime(DateTime.Now));
+        });
+    }
+    
+    [Fact]
+    void TestConstructorWithAnteriorDate()
+    {
+        Assert.Throws<ArgumentOutOfRangeException>(() =>
+        {
+            BlackList blackList = new BlackList("example@email.com", DateOnly.FromDateTime(DateTime.Parse("2024/01/01 00:00:00")));
+        });
+    }
+}

API_SQLuedo/TestEF/Model/InquiryTableTest.cs

@@ -0,0 +1,24 @@
+using Model;
+
+namespace TestEF.Model;
+
+public class InquiryTableTest
+{
+    [Fact]
+    void TestEmptyContructor()
+    {
+        InquiryTable inquiry = new InquiryTable();
+        Assert.Equal(0,inquiry.OwnerId);
+        Assert.Null(inquiry.ConnectionInfo);
+        Assert.Null(inquiry.DatabaseName);
+    }
+    
+    [Fact]
+    void TestFullContructor()
+    {
+        InquiryTable inquiry = new InquiryTable(1,"Database","Connection");
+        Assert.Equal(1,inquiry.OwnerId);
+        Assert.Equal("Connection",inquiry.ConnectionInfo);
+        Assert.Equal("Database",inquiry.DatabaseName);
+    }
+}

API_SQLuedo/TestEF/Model/InquiryTest.cs

@@ -0,0 +1,26 @@
+using Model;
+
+namespace TestEF.Model;
+
+public class InquiryTest
+{
+    [Fact]
+    void TestEmptyContructor()
+    {
+        Inquiry inquiry = new Inquiry();
+        Assert.Equal(0,inquiry.Id);
+        Assert.Null(inquiry.Title);
+        Assert.Null(inquiry.Description);
+        Assert.False(inquiry.IsUser);
+    }
+    
+    [Fact]
+    void TestFullContructor()
+    {
+        Inquiry inquiry = new Inquiry(1,"Title","Description",true);
+        Assert.Equal(1,inquiry.Id);
+        Assert.Equal("Title",inquiry.Title);
+        Assert.Equal("Description",inquiry.Description);
+        Assert.True(inquiry.IsUser);
+    }
+}

API_SQLuedo/TestEF/Model/LessonTest.cs

@@ -0,0 +1,26 @@
+using Model;
+
+namespace TestEF.Model;
+
+public class LessonTest
+{
+    [Fact]
+    void TestConstructorWithoutId()
+    {
+        Lesson lesson = new Lesson("Title", "JohnDoe", DateOnly.FromDateTime(DateTime.Now));
+        Assert.Equal(0, lesson.Id);
+        Assert.Equal("Title", lesson.Title);
+        Assert.Equal("JohnDoe", lesson.LastPublisher);
+        Assert.Equal(DateOnly.FromDateTime(DateTime.Now), lesson.LastEdit);
+    }
+    
+    [Fact]
+    void TestConstructorWithId()
+    {
+        Lesson lesson = new Lesson(42,"Title", "JohnDoe", DateOnly.FromDateTime(DateTime.Now));
+        Assert.Equal(42, lesson.Id);
+        Assert.Equal("Title", lesson.Title);
+        Assert.Equal("JohnDoe", lesson.LastPublisher);
+        Assert.Equal(DateOnly.FromDateTime(DateTime.Now), lesson.LastEdit);
+    }
+}

API_SQLuedo/TestEF/Model/NotepadTest.cs

@@ -0,0 +1,36 @@
+using Model;
+
+namespace TestEF.Model;
+
+public class NotepadTest
+{
+    [Fact]
+    void TestEmptyConstructor()
+    {
+        Notepad notepad = new Notepad();
+        Assert.Equal(0, notepad.Id);
+        Assert.Equal(0, notepad.UserId);
+        Assert.Equal(0, notepad.InquiryId);
+        Assert.Null(notepad.Notes);
+    }
+    
+    [Fact]
+    void TestConstructorWithoutId()
+    {
+        Notepad notepad = new Notepad(42,42,"Notes");
+        Assert.Equal(0, notepad.Id);
+        Assert.Equal(42, notepad.UserId);
+        Assert.Equal(42, notepad.InquiryId);
+        Assert.Equal("Notes",notepad.Notes);
+    }
+    
+    [Fact]
+    void TestConstructorWithId()
+    {
+        Notepad notepad = new Notepad(42,42,42,"Notes");
+        Assert.Equal(42, notepad.Id);
+        Assert.Equal(42, notepad.UserId);
+        Assert.Equal(42, notepad.InquiryId);
+        Assert.Equal("Notes",notepad.Notes);
+    }
+}

API_SQLuedo/TestEF/Model/ParagraphTest.cs

@@ -0,0 +1,32 @@
+using Model;
+
+namespace TestEF.Model;
+
+public class ParagraphTest
+{
+    [Fact]
+    void TestConstructorWithoutId()
+    {
+        Paragraph paragraph = new Paragraph("Title", "Content","Info","Query","Comment");
+        Assert.Equal(0, paragraph.Id);
+        Assert.Equal(0, paragraph.LessonId);
+        Assert.Equal("Title", paragraph.ContentTitle);
+        Assert.Equal("Content", paragraph.ContentContent);
+        Assert.Equal("Info", paragraph.Info);
+        Assert.Equal("Query", paragraph.Query);
+        Assert.Equal("Comment", paragraph.Comment);
+    }
+    
+    [Fact]
+    void TestConstructorWithId()
+    {
+        Paragraph paragraph = new Paragraph(42,"Title", "Content","Info","Query","Comment",42);
+        Assert.Equal(42, paragraph.Id);
+        Assert.Equal(42, paragraph.LessonId);
+        Assert.Equal("Title", paragraph.ContentTitle);
+        Assert.Equal("Content", paragraph.ContentContent);
+        Assert.Equal("Info", paragraph.Info);
+        Assert.Equal("Query", paragraph.Query);
+        Assert.Equal("Comment", paragraph.Comment);
+    }
+}

API_SQLuedo/TestEF/Model/SolutionTest.cs

@@ -0,0 +1,42 @@
+using Model;
+
+namespace TestEF.Model;
+
+public class SolutionTest
+{
+    [Fact]
+    void TestEmptyConstructor()
+    {
+        Solution solution = new Solution();
+        Assert.Equal(0,solution.OwnerId);
+        Assert.Null(solution.MurdererFirstName);
+        Assert.Null(solution.MurdererLastName);
+        Assert.Null(solution.MurderPlace);
+        Assert.Null(solution.MurderWeapon);
+        Assert.Null(solution.Explaination);
+    }
+    
+    [Fact]
+    void TestConstructorWithoutId()
+    {
+        Solution solution = new Solution("John","Doe","Bedroom","Knife","Because");
+        Assert.Equal(0,solution.OwnerId);
+        Assert.Equal("John",solution.MurdererFirstName);
+        Assert.Equal("Doe",solution.MurdererLastName);
+        Assert.Equal("Bedroom",solution.MurderPlace);
+        Assert.Equal("Knife",solution.MurderWeapon);
+        Assert.Equal("Because",solution.Explaination);
+    }
+    
+    [Fact]
+    void TestConstructorWithId()
+    {
+        Solution solution = new Solution(42,"John","Doe","Bedroom","Knife","Because");
+        Assert.Equal(42,solution.OwnerId);
+        Assert.Equal("John",solution.MurdererFirstName);
+        Assert.Equal("Doe",solution.MurdererLastName);
+        Assert.Equal("Bedroom",solution.MurderPlace);
+        Assert.Equal("Knife",solution.MurderWeapon);
+        Assert.Equal("Because",solution.Explaination);
+    }
+}

API_SQLuedo/TestEF/Model/SuccessTest.cs

@@ -0,0 +1,24 @@
+using Model;
+
+namespace TestEF.Model;
+
+public class SuccessTest
+{
+    [Fact]
+    void TestEmptyConstructor()
+    {
+        Success success = new Success();
+        Assert.Equal(0,success.UserId);
+        Assert.Equal(0,success.InquiryId);
+        Assert.False(success.IsFinished);
+    }
+    
+    [Fact]
+    void TestFullConstructor()
+    {
+        Success success = new Success(42,42,true);
+        Assert.Equal(42,success.UserId);
+        Assert.Equal(42,success.InquiryId);
+        Assert.True(success.IsFinished);
+    }
+}

API_SQLuedo/TestEF/Model/UserTest.cs

@@ -0,0 +1,28 @@
+using Model;
+
+namespace TestEF.Model;
+
+public class UserTest
+{
+    [Fact]
+    void TestEmptyConstructor()
+    {
+        User user = new User();
+        Assert.Equal(0,user.Id);
+        Assert.Null(user.Username);
+        Assert.Null(user.Email);
+        Assert.Null(user.Password);
+        Assert.False(user.IsAdmin);
+    }
+    
+    [Fact]
+    void TestFullConstructor()
+    {
+        User user = new User(42,"Username","Password","Email",true);
+        Assert.Equal(42,user.Id);
+        Assert.Equal("Username",user.Username);
+        Assert.Equal("Email",user.Email);
+        Assert.Equal("Password",user.Password);
+        Assert.True(user.IsAdmin);
+    }
+}

API_SQLuedo/TestEF/Service/TestBlackListDataService.cs

@@ -0,0 +1,87 @@
+using DbContextLib;
+using DbDataManager.Service;
+using Entities;
+using Microsoft.Data.Sqlite;
+using Microsoft.EntityFrameworkCore;
+using Model.OrderCriteria;
+
+namespace TestEF.Service;
+
+public class TestBlackListDataService
+{
+    private readonly UserDbContext _dbContext;
+    private readonly BlackListDataService _blackListDataService;
+
+    public TestBlackListDataService()
+    {
+        var connection = new SqliteConnection("DataSource=:memory:");
+        connection.Open();
+        var options = new DbContextOptionsBuilder<UserDbContext>()
+            .UseSqlite(connection)
+            .Options;
+
+        _dbContext = new UserDbContext(options);
+        _blackListDataService = new BlackListDataService(_dbContext);
+    }
+    [Fact]
+    public void BanUser_Success()
+    {
+        _dbContext.Users.Add(new UserEntity() { Id = 1, Username = "Test101", Email = "example101@email.com", Password = "password", IsAdmin = true });
+        _dbContext.Users.Add(new UserEntity() { Id = 2, Username = "Test102", Email = "example102@email.com", Password = "password", IsAdmin = false });
+        _dbContext.Users.Add(new UserEntity() { Id = 3, Username = "Test103", Email = "example103@email.com", Password = "password", IsAdmin = true });
+        _dbContext.SaveChanges();
+        var banResult = _blackListDataService.BanUser("Test101");
+        Assert.True(banResult);
+    }
+    
+    [Fact]
+    public void GetNbBannedUsers()
+    {
+        _dbContext.Users.Add(new UserEntity() { Id = 1, Username = "Test61", Email = "example61@email.com", Password = "password", IsAdmin = true });
+        _dbContext.Users.Add(new UserEntity() { Id = 2, Username = "Test62", Email = "example62@email.com", Password = "password", IsAdmin = false });
+        _dbContext.Users.Add(new UserEntity() { Id = 3, Username = "Test63", Email = "example63@email.com", Password = "password", IsAdmin = true });
+        _dbContext.SaveChanges();
+        var banResult1 = _blackListDataService.BanUser("Test61");
+        var banResult2 = _blackListDataService.BanUser("Test62");
+        var banResult3 = _blackListDataService.BanUser("Test63");
+        Assert.True(banResult1);
+        Assert.True(banResult2);
+        Assert.True(banResult3);
+        Assert.Equal(3, _dbContext.BlackLists.Count());
+    }
+    
+    [Fact]
+    public void BanUser_Fail()
+    {
+        _dbContext.Users.Add(new UserEntity() { Id = 1, Username = "Test71", Email = "example71@email.com", Password = "password", IsAdmin = true });
+        _dbContext.Users.Add(new UserEntity() { Id = 2, Username = "Test72", Email = "example72@email.com", Password = "password", IsAdmin = false });
+        _dbContext.Users.Add(new UserEntity() { Id = 3, Username = "Test73", Email = "example73@email.com", Password = "password", IsAdmin = true });
+        _dbContext.SaveChanges();
+        var banResult = _blackListDataService.BanUser("Test42");
+        Assert.False(banResult);
+    }
+    
+    [Fact]
+    public void IsBanned_Success()
+    {
+        _dbContext.Users.Add(new UserEntity() { Id = 1, Username = "Test81", Email = "example81@email.com", Password = "password", IsAdmin = true });
+        _dbContext.Users.Add(new UserEntity() { Id = 2, Username = "Test82", Email = "example82@email.com", Password = "password", IsAdmin = false });
+        _dbContext.Users.Add(new UserEntity() { Id = 3, Username = "Test83", Email = "example83@email.com", Password = "password", IsAdmin = true });
+        _dbContext.SaveChanges();
+        var banResult = _blackListDataService.BanUser("Test81");
+        Assert.True(banResult);
+        Assert.NotNull(_blackListDataService.GetUserBannedByEmail("example81@email.com"));
+    }
+    
+    [Fact]
+    public void UnbanUser_Success()
+    {
+        _dbContext.Users.Add(new UserEntity() { Id = 1, Username = "Test91", Email = "example91@email.com", Password = "password", IsAdmin = true });
+        _dbContext.Users.Add(new UserEntity() { Id = 2, Username = "Test92", Email = "example92@email.com", Password = "password", IsAdmin = false });
+        _dbContext.Users.Add(new UserEntity() { Id = 3, Username = "Test93", Email = "example93@email.com", Password = "password", IsAdmin = true });
+        _dbContext.SaveChanges();
+        var banResult = _blackListDataService.BanUser("Test91");
+        Assert.True(banResult);
+        Assert.True(_blackListDataService.UnbanUser("example91@email.com"));
+    }
+}

API_SQLuedo/TestEF/Service/TestInquiryDataService.cs

@@ -0,0 +1,211 @@
+using DbContextLib;
+using DbDataManager.Service;
+using Entities;
+using Microsoft.Data.Sqlite;
+using Microsoft.EntityFrameworkCore;
+using Model.OrderCriteria;
+
+namespace TestEF.Service;
+
+public class TestInquiryDataService
+{
+    private readonly UserDbContext _dbContext;
+    private readonly InquiryDataService _inquiryDataService;
+
+    public TestInquiryDataService()
+    {
+        var connection = new SqliteConnection("DataSource=:memory:");
+        connection.Open();
+        var options = new DbContextOptionsBuilder<UserDbContext>()
+            .UseSqlite(connection)
+            .Options;
+
+        _dbContext = new UserDbContext(options);
+        _inquiryDataService = new InquiryDataService(_dbContext);
+    }
+
+    [Fact]
+    public void GetInquiries_WithNoneCriteria_ReturnsCorrectNumberOfInquiries()
+    {
+        _dbContext.Inquiries.Add(new InquiryEntity { Id = 1, Title = "Test1", Description = "Desc1", IsUser = true });
+        _dbContext.Inquiries.Add(new InquiryEntity { Id = 2, Title = "Test2", Description = "Desc2", IsUser = false });
+        _dbContext.Inquiries.Add(new InquiryEntity { Id = 3, Title = "Test3", Description = "Desc3", IsUser = true });
+        _dbContext.SaveChanges();
+
+        var result = _inquiryDataService.GetInquiries(1, 2, InquiryOrderCriteria.None);
+
+        Assert.Equal(2, result.Count());
+    }
+    
+    [Fact]
+    public void GetNumberOfInquiries()
+    {
+        _dbContext.Inquiries.Add(new InquiryEntity { Id = 1, Title = "Test1", Description = "Desc1", IsUser = true });
+        _dbContext.Inquiries.Add(new InquiryEntity { Id = 2, Title = "Test2", Description = "Desc2", IsUser = false });
+        _dbContext.Inquiries.Add(new InquiryEntity { Id = 3, Title = "Test3", Description = "Desc3", IsUser = true });
+        _dbContext.SaveChanges();
+
+        var result = _inquiryDataService.GetNumberOfInquiries();
+
+        Assert.Equal(3, result);
+    }
+    
+    [Fact]
+    public void GetInquiries_OrderedByTitle_ReturnsCorrectNumberOfInquiries()
+    {
+        _dbContext.Inquiries.Add(new InquiryEntity { Id = 1, Title = "Test1", Description = "Desc1", IsUser = true });
+        _dbContext.Inquiries.Add(new InquiryEntity { Id = 2, Title = "Test2", Description = "Desc2", IsUser = false });
+        _dbContext.Inquiries.Add(new InquiryEntity { Id = 3, Title = "Test3", Description = "Desc3", IsUser = true });
+        _dbContext.SaveChanges();
+
+        var result = _inquiryDataService.GetInquiries(1, 2, InquiryOrderCriteria.ByTitle);
+
+        Assert.Equal(2, result.Count());
+    }
+    
+    [Fact]
+    public void GetInquiries_OrderedByDescription_ReturnsCorrectNumberOfInquiries()
+    {
+        _dbContext.Inquiries.Add(new InquiryEntity { Id = 1, Title = "Test1", Description = "Desc1", IsUser = true });
+        _dbContext.Inquiries.Add(new InquiryEntity { Id = 2, Title = "Test2", Description = "Desc2", IsUser = false });
+        _dbContext.Inquiries.Add(new InquiryEntity { Id = 3, Title = "Test3", Description = "Desc3", IsUser = true });
+        _dbContext.SaveChanges();
+
+        var result = _inquiryDataService.GetInquiries(1, 2, InquiryOrderCriteria.ByDescription);
+
+        Assert.Equal(2, result.Count());
+    }
+    
+    [Fact]
+    public void GetInquiries_OrderedByIsUser_ReturnsCorrectNumberOfInquiries()
+    {
+        _dbContext.Inquiries.Add(new InquiryEntity { Id = 1, Title = "Test1", Description = "Desc1", IsUser = true });
+        _dbContext.Inquiries.Add(new InquiryEntity { Id = 2, Title = "Test2", Description = "Desc2", IsUser = false });
+        _dbContext.Inquiries.Add(new InquiryEntity { Id = 3, Title = "Test3", Description = "Desc3", IsUser = true });
+        _dbContext.SaveChanges();
+
+        var result = _inquiryDataService.GetInquiries(1, 2, InquiryOrderCriteria.ByIsUser);
+
+        Assert.Equal(2, result.Count());
+    }
+
+    [Fact]
+    public void GetInquiryById_ReturnsCorrectInquiry()
+    {
+        _dbContext.Inquiries.Add(new InquiryEntity { Id = 1, Title = "Test1", Description = "Desc1", IsUser = true });
+        _dbContext.Inquiries.Add(new InquiryEntity { Id = 2, Title = "Test2", Description = "Desc2", IsUser = false });
+        _dbContext.SaveChanges();
+
+        var result = _inquiryDataService.GetInquiryById(1);
+
+        Assert.Equal("Test1", result.Title);
+    }
+
+    [Fact]
+    public void GetInquiryByTitle_ReturnsCorrectInquiry()
+    {
+        _dbContext.Inquiries.Add(new InquiryEntity { Id = 1, Title = "Test1", Description = "Desc1", IsUser = true });
+        _dbContext.Inquiries.Add(new InquiryEntity { Id = 2, Title = "Test2", Description = "Desc2", IsUser = false });
+        _dbContext.SaveChanges();
+
+        var result = _inquiryDataService.GetInquiryByTitle("Test1");
+
+        Assert.Equal(1, result.Id);
+    }
+
+    [Fact]
+    public void CreateInquiry_AddsNewInquiry()
+    {
+        var result = _inquiryDataService.CreateInquiry("Test", "Desc", true);
+
+        Assert.Equal(1, _dbContext.Inquiries.Count());
+        Assert.Equal("Test", result.Title);
+    }
+
+    [Fact]
+    public void DeleteInquiry_RemovesInquiry()
+    {
+        _dbContext.Inquiries.Add(new InquiryEntity { Id = 1, Title = "Test1", Description = "Desc1", IsUser = true });
+        _dbContext.SaveChanges();
+
+        _inquiryDataService.DeleteInquiry(1);
+
+        Assert.Empty(_dbContext.Inquiries);
+    }
+
+    [Fact]
+    public void UpdateInquiry_UpdatesExistingInquiry()
+    {
+        _dbContext.Inquiries.Add(new InquiryEntity { Id = 1, Title = "Test1", Description = "Desc1", IsUser = true });
+        _dbContext.SaveChanges();
+
+        var updatedInquiry = new InquiryEntity { Id = 1, Title = "Updated", Description = "Desc", IsUser = false };
+        var result = _inquiryDataService.UpdateInquiry(1, updatedInquiry);
+
+        Assert.Equal("Updated", result.Title);
+    }
+
+    [Fact]
+    public void GetInquiries_WithBadPage_ReturnsClassicInquiries()
+    {
+        _dbContext.Inquiries.Add(new InquiryEntity { Id = 1, Title = "Test1", Description = "Desc1", IsUser = true });
+        _dbContext.Inquiries.Add(new InquiryEntity { Id = 2, Title = "Test2", Description = "Desc2", IsUser = false });
+        _dbContext.SaveChanges();
+
+        var result = _inquiryDataService.GetInquiries(-1, 2, InquiryOrderCriteria.None);
+
+        Assert.Equal(2, result.Count());
+    }
+    
+    [Fact]
+    public void GetInquiries_WithBadNumber_ReturnsClassicInquiries()
+    {
+        _dbContext.Inquiries.Add(new InquiryEntity { Id = 1, Title = "Test1", Description = "Desc1", IsUser = true });
+        _dbContext.Inquiries.Add(new InquiryEntity { Id = 2, Title = "Test2", Description = "Desc2", IsUser = false });
+        _dbContext.SaveChanges();
+
+        var result = _inquiryDataService.GetInquiries(1, -42, InquiryOrderCriteria.None);
+
+        Assert.Equal(2, result.Count());
+    }
+
+    [Fact]
+    public void GetInquiryById_WithoutId_ThrowsException()
+    {
+        _dbContext.Inquiries.Add(new InquiryEntity { Id = 1, Title = "Test1", Description = "Desc1", IsUser = true });
+        _dbContext.SaveChanges();
+
+        Assert.Throws<ArgumentException>(() => _inquiryDataService.GetInquiryById(2));
+    }
+
+    [Fact]
+    public void GetInquiryByTitle_WithoutTitle_ThrowsException()
+    {
+        _dbContext.Inquiries.Add(new InquiryEntity { Id = 1, Title = "Test1", Description = "Desc1", IsUser = true });
+        _dbContext.SaveChanges();
+
+        Assert.Throws<ArgumentException>(() => _inquiryDataService.GetInquiryByTitle("Test2"));
+    }
+
+    [Fact]
+    public void DeleteInquiry_WithoutId_ReturnsFalse()
+    {
+        _dbContext.Inquiries.Add(new InquiryEntity { Id = 1, Title = "Test1", Description = "Desc1", IsUser = true });
+        _dbContext.SaveChanges();
+
+        var result = _inquiryDataService.DeleteInquiry(2);
+
+        Assert.False(result);
+    }
+
+    [Fact]
+    public void UpdateInquiry_WithoutId_ThrowsException()
+    {
+        _dbContext.Inquiries.Add(new InquiryEntity { Id = 1, Title = "Test1", Description = "Desc1", IsUser = true });
+        _dbContext.SaveChanges();
+
+        var updatedInquiry = new InquiryEntity { Id = 2, Title = "Updated", Description = "Desc", IsUser = false };
+
+        Assert.Throws<ArgumentException>(() => _inquiryDataService.UpdateInquiry(2, updatedInquiry));
+    }
+}

API_SQLuedo/TestEF/Service/TestLessonDataService.cs

@@ -0,0 +1,185 @@
+using DbContextLib;
+using DbDataManager.Service;
+using Entities;
+using Microsoft.Data.Sqlite;
+using Microsoft.EntityFrameworkCore;
+using Model.OrderCriteria;
+
+namespace TestEF.Service;
+
+public class TestLessonDataService
+{
+    private readonly UserDbContext _dbContext;
+    private readonly LessonDataService _lessonDataService;
+
+    public TestLessonDataService()
+    {
+        var connection = new SqliteConnection("DataSource=:memory:");
+        connection.Open();
+        var options = new DbContextOptionsBuilder<UserDbContext>()
+            .UseSqlite(connection)
+            .Options;
+
+        _dbContext = new UserDbContext(options);
+        _lessonDataService = new LessonDataService(_dbContext);
+    }
+
+    [Fact]
+    public void GetLessons_WithNoneCriteria_ReturnsCorrectNumberOfLessons()
+    {
+        _dbContext.Lessons.Add(new LessonEntity
+            { Id = 1, Title = "Test1", LastPublisher = "Publisher1", LastEdit = DateOnly.MinValue });
+        _dbContext.Lessons.Add(new LessonEntity
+            { Id = 2, Title = "Test2", LastPublisher = "Publisher2", LastEdit = DateOnly.MinValue });
+        _dbContext.Lessons.Add(new LessonEntity
+            { Id = 3, Title = "Test3", LastPublisher = "Publisher3", LastEdit = DateOnly.MinValue });
+        _dbContext.SaveChanges();
+
+        var result = _lessonDataService.GetLessons(1, 2, LessonOrderCriteria.None);
+
+        Assert.Equal(2, result.Count());
+    }
+    
+    [Fact]
+    public void GetLessons_OrderedByTitle_ReturnsCorrectNumberOfLessons()
+    {
+        _dbContext.Lessons.Add(new LessonEntity
+            { Id = 1, Title = "Test1", LastPublisher = "Publisher1", LastEdit = DateOnly.MinValue });
+        _dbContext.Lessons.Add(new LessonEntity
+            { Id = 2, Title = "Test2", LastPublisher = "Publisher2", LastEdit = DateOnly.MinValue });
+        _dbContext.Lessons.Add(new LessonEntity
+            { Id = 3, Title = "Test3", LastPublisher = "Publisher3", LastEdit = DateOnly.MinValue });
+        _dbContext.SaveChanges();
+
+        var result = _lessonDataService.GetLessons(1, 2, LessonOrderCriteria.ByTitle);
+
+        Assert.Equal(2, result.Count());
+    }
+    
+    [Fact]
+    public void GetLessons_OrderedByLastPublisher_ReturnsCorrectNumberOfLessons()
+    {
+        _dbContext.Lessons.Add(new LessonEntity
+            { Id = 1, Title = "Test1", LastPublisher = "Publisher1", LastEdit = DateOnly.MinValue });
+        _dbContext.Lessons.Add(new LessonEntity
+            { Id = 2, Title = "Test2", LastPublisher = "Publisher2", LastEdit = DateOnly.MinValue });
+        _dbContext.Lessons.Add(new LessonEntity
+            { Id = 3, Title = "Test3", LastPublisher = "Publisher3", LastEdit = DateOnly.MinValue });
+        _dbContext.SaveChanges();
+
+        var result = _lessonDataService.GetLessons(1, 2, LessonOrderCriteria.ByLastPublisher);
+
+        Assert.Equal(2, result.Count());
+    }
+    
+    [Fact]
+    public void GetLessons_OrderedByLastEdit_ReturnsCorrectNumberOfLessons()
+    {
+        _dbContext.Lessons.Add(new LessonEntity
+            { Id = 1, Title = "Test1", LastPublisher = "Publisher1", LastEdit = DateOnly.MinValue });
+        _dbContext.Lessons.Add(new LessonEntity
+            { Id = 2, Title = "Test2", LastPublisher = "Publisher2", LastEdit = DateOnly.MinValue });
+        _dbContext.Lessons.Add(new LessonEntity
+            { Id = 3, Title = "Test3", LastPublisher = "Publisher3", LastEdit = DateOnly.MinValue });
+        _dbContext.SaveChanges();
+
+        var result = _lessonDataService.GetLessons(1, 2, LessonOrderCriteria.ByLastEdit);
+
+        Assert.Equal(2, result.Count());
+    }
+    
+    [Fact]
+    public void GetLessons_WithBadPage_ReturnsCorrectNumberOfLessons()
+    {
+        _dbContext.Lessons.Add(new LessonEntity
+            { Id = 1, Title = "Test1", LastPublisher = "Publisher1", LastEdit = DateOnly.MinValue });
+        _dbContext.Lessons.Add(new LessonEntity
+            { Id = 2, Title = "Test2", LastPublisher = "Publisher2", LastEdit = DateOnly.MinValue });
+        _dbContext.Lessons.Add(new LessonEntity
+            { Id = 3, Title = "Test3", LastPublisher = "Publisher3", LastEdit = DateOnly.MinValue });
+        _dbContext.SaveChanges();
+
+        var result = _lessonDataService.GetLessons(-42, 2, LessonOrderCriteria.None);
+
+        Assert.Equal(2, result.Count());
+    }
+    
+    [Fact]
+    public void GetLessons_WithBadNumber_ReturnsCorrectNumberOfLessons()
+    {
+        _dbContext.Lessons.Add(new LessonEntity
+            { Id = 1, Title = "Test1", LastPublisher = "Publisher1", LastEdit = DateOnly.MinValue });
+        _dbContext.Lessons.Add(new LessonEntity
+            { Id = 2, Title = "Test2", LastPublisher = "Publisher2", LastEdit = DateOnly.MinValue });
+        _dbContext.Lessons.Add(new LessonEntity
+            { Id = 3, Title = "Test3", LastPublisher = "Publisher3", LastEdit = DateOnly.MinValue });
+        _dbContext.SaveChanges();
+
+        var result = _lessonDataService.GetLessons(1, -42, LessonOrderCriteria.None);
+
+        Assert.Equal(3, result.Count());
+    }
+
+    [Fact]
+    public void GetLessonById_ReturnsCorrectLesson()
+    {
+        _dbContext.Lessons.Add(new LessonEntity
+            { Id = 1, Title = "Test1", LastPublisher = "Publisher1", LastEdit = DateOnly.MinValue });
+        _dbContext.Lessons.Add(new LessonEntity
+            { Id = 2, Title = "Test2", LastPublisher = "Publisher2", LastEdit = DateOnly.MinValue });
+        _dbContext.SaveChanges();
+
+        var result = _lessonDataService.GetLessonById(1);
+
+        Assert.Equal("Test1", result.Title);
+    }
+
+    [Fact]
+    public void GetLessonByTitle_ReturnsCorrectLesson()
+    {
+        _dbContext.Lessons.Add(new LessonEntity
+            { Id = 1, Title = "Test1", LastPublisher = "Publisher1", LastEdit = DateOnly.MinValue });
+        _dbContext.Lessons.Add(new LessonEntity
+            { Id = 2, Title = "Test2", LastPublisher = "Publisher2", LastEdit = DateOnly.MinValue });
+        _dbContext.SaveChanges();
+
+        var result = _lessonDataService.GetLessonByTitle("Test1");
+
+        Assert.Equal(1, result.Id);
+    }
+
+    [Fact]
+    public void CreateLesson_AddsNewLesson()
+    {
+        var result = _lessonDataService.CreateLesson(1, "Test", "Publisher", DateOnly.MinValue);
+
+        Assert.Equal(1, _dbContext.Lessons.Count());
+        Assert.Equal("Test", result.Title);
+    }
+
+    [Fact]
+    public void DeleteLesson_RemovesLesson()
+    {
+        _dbContext.Lessons.Add(new LessonEntity
+            { Id = 1, Title = "Test1", LastPublisher = "Publisher1", LastEdit = DateOnly.MinValue });
+        _dbContext.SaveChanges();
+
+        _lessonDataService.DeleteLesson(1);
+
+        Assert.Empty(_dbContext.Lessons);
+    }
+
+    [Fact]
+    public void UpdateLesson_UpdatesExistingLesson()
+    {
+        _dbContext.Lessons.Add(new LessonEntity
+            { Id = 1, Title = "Test1", LastPublisher = "Publisher1", LastEdit = DateOnly.MinValue });
+        _dbContext.SaveChanges();
+
+        var updatedLesson = new LessonEntity
+            { Id = 1, Title = "Updated", LastPublisher = "Publisher", LastEdit = DateOnly.MinValue };
+        var result = _lessonDataService.UpdateLesson(1, updatedLesson);
+
+        Assert.Equal("Updated", result.Title);
+    }
+}

API_SQLuedo/TestEF/Service/TestParagraphDataService.cs

@@ -0,0 +1,362 @@
+using DbContextLib;
+using DbDataManager.Service;
+using Entities;
+using Microsoft.Data.Sqlite;
+using Microsoft.EntityFrameworkCore;
+using Model.OrderCriteria;
+
+namespace TestEF.Service;
+
+public class TestParagraphDataService
+{
+    private readonly UserDbContext _dbContext;
+    private readonly ParagraphDataService _paragraphDataService;
+    private readonly LessonEntity _lesson;
+
+    public TestParagraphDataService()
+    {
+        var connection = new SqliteConnection("DataSource=:memory:");
+        connection.Open();
+        var options = new DbContextOptionsBuilder<UserDbContext>()
+            .UseSqlite(connection)
+            .Options;
+
+        _dbContext = new UserDbContext(options);
+        _lesson = new LessonEntity
+        {
+            Id = 1, Title = "Test", LastPublisher = "Publisher", LastEdit = DateOnly.MinValue
+        };
+        _paragraphDataService = new ParagraphDataService(_dbContext);
+    }
+
+    [Fact]
+    public void GetParagraphs_WithoutCriteria_ReturnsCorrectNumberOfParagraphs()
+    {
+        _dbContext.Lessons.Add(_lesson);
+        _dbContext.SaveChanges();
+
+        _dbContext.Paragraphs.Add(new ParagraphEntity
+        {
+            Id = 1, ContentContent = "ContentContent1", ContentTitle = "ContentTitle1", Title = "Test1",
+            Content = "Content1", Info = "Info1", Query = "Query1", Comment = "Comment1",
+            LessonId = 1
+        });
+        _dbContext.Paragraphs.Add(new ParagraphEntity
+        {
+            Id = 2, ContentContent = "ContentContent2", ContentTitle = "ContentTitl2", Title = "Test2",
+            Content = "Content2", Info = "Info2", Query = "Query2", Comment = "Comment2",
+            LessonId = 1
+        });
+        _dbContext.Paragraphs.Add(new ParagraphEntity
+        {
+            Id = 3, ContentContent = "ContentContent3", ContentTitle = "ContentTitle3", Title = "Test3",
+            Content = "Content3", Info = "Info3", Query = "Query3", Comment = "Comment3",
+            LessonId = 1
+        });
+        _dbContext.SaveChanges();
+
+        var result = _paragraphDataService.GetParagraphs(1, 2, ParagraphOrderCriteria.None);
+
+        Assert.Equal(2, result.Count());
+    }
+    
+    [Fact]
+    public void GetParagraphs_OrderdByTitle_ReturnsCorrectNumberOfParagraphs()
+    {
+        _dbContext.Lessons.Add(_lesson);
+        _dbContext.SaveChanges();
+
+        _dbContext.Paragraphs.Add(new ParagraphEntity
+        {
+            Id = 1, ContentContent = "ContentContent1", ContentTitle = "ContentTitle1", Title = "Test1",
+            Content = "Content1", Info = "Info1", Query = "Query1", Comment = "Comment1",
+            LessonId = 1
+        });
+        _dbContext.Paragraphs.Add(new ParagraphEntity
+        {
+            Id = 2, ContentContent = "ContentContent2", ContentTitle = "ContentTitl2", Title = "Test2",
+            Content = "Content2", Info = "Info2", Query = "Query2", Comment = "Comment2",
+            LessonId = 1
+        });
+        _dbContext.Paragraphs.Add(new ParagraphEntity
+        {
+            Id = 3, ContentContent = "ContentContent3", ContentTitle = "ContentTitle3", Title = "Test3",
+            Content = "Content3", Info = "Info3", Query = "Query3", Comment = "Comment3",
+            LessonId = 1
+        });
+        _dbContext.SaveChanges();
+
+        var result = _paragraphDataService.GetParagraphs(1, 2, ParagraphOrderCriteria.ByTitle);
+
+        Assert.Equal(2, result.Count());
+    }
+    
+    [Fact]
+    public void GetParagraphs_OrderedByContent_ReturnsCorrectNumberOfParagraphs()
+    {
+        _dbContext.Lessons.Add(_lesson);
+        _dbContext.SaveChanges();
+
+        _dbContext.Paragraphs.Add(new ParagraphEntity
+        {
+            Id = 1, ContentContent = "ContentContent1", ContentTitle = "ContentTitle1", Title = "Test1",
+            Content = "Content1", Info = "Info1", Query = "Query1", Comment = "Comment1",
+            LessonId = 1
+        });
+        _dbContext.Paragraphs.Add(new ParagraphEntity
+        {
+            Id = 2, ContentContent = "ContentContent2", ContentTitle = "ContentTitl2", Title = "Test2",
+            Content = "Content2", Info = "Info2", Query = "Query2", Comment = "Comment2",
+            LessonId = 1
+        });
+        _dbContext.Paragraphs.Add(new ParagraphEntity
+        {
+            Id = 3, ContentContent = "ContentContent3", ContentTitle = "ContentTitle3", Title = "Test3",
+            Content = "Content3", Info = "Info3", Query = "Query3", Comment = "Comment3",
+            LessonId = 1
+        });
+        _dbContext.SaveChanges();
+
+        var result = _paragraphDataService.GetParagraphs(1, 2, ParagraphOrderCriteria.ByContent);
+
+        Assert.Equal(2, result.Count());
+    }
+    
+    [Fact]
+    public void GetParagraphs_OrderedByQuery_ReturnsCorrectNumberOfParagraphs()
+    {
+        _dbContext.Lessons.Add(_lesson);
+        _dbContext.SaveChanges();
+
+        _dbContext.Paragraphs.Add(new ParagraphEntity
+        {
+            Id = 1, ContentContent = "ContentContent1", ContentTitle = "ContentTitle1", Title = "Test1",
+            Content = "Content1", Info = "Info1", Query = "Query1", Comment = "Comment1",
+            LessonId = 1
+        });
+        _dbContext.Paragraphs.Add(new ParagraphEntity
+        {
+            Id = 2, ContentContent = "ContentContent2", ContentTitle = "ContentTitl2", Title = "Test2",
+            Content = "Content2", Info = "Info2", Query = "Query2", Comment = "Comment2",
+            LessonId = 1
+        });
+        _dbContext.Paragraphs.Add(new ParagraphEntity
+        {
+            Id = 3, ContentContent = "ContentContent3", ContentTitle = "ContentTitle3", Title = "Test3",
+            Content = "Content3", Info = "Info3", Query = "Query3", Comment = "Comment3",
+            LessonId = 1
+        });
+        _dbContext.SaveChanges();
+
+        var result = _paragraphDataService.GetParagraphs(1, 2, ParagraphOrderCriteria.ByQuery);
+
+        Assert.Equal(2, result.Count());
+    }
+    
+    [Fact]
+    public void GetParagraphs_OrderedByInfo_ReturnsCorrectNumberOfParagraphs()
+    {
+        _dbContext.Lessons.Add(_lesson);
+        _dbContext.SaveChanges();
+
+        _dbContext.Paragraphs.Add(new ParagraphEntity
+        {
+            Id = 1, ContentContent = "ContentContent1", ContentTitle = "ContentTitle1", Title = "Test1",
+            Content = "Content1", Info = "Info1", Query = "Query1", Comment = "Comment1",
+            LessonId = 1
+        });
+        _dbContext.Paragraphs.Add(new ParagraphEntity
+        {
+            Id = 2, ContentContent = "ContentContent2", ContentTitle = "ContentTitl2", Title = "Test2",
+            Content = "Content2", Info = "Info2", Query = "Query2", Comment = "Comment2",
+            LessonId = 1
+        });
+        _dbContext.Paragraphs.Add(new ParagraphEntity
+        {
+            Id = 3, ContentContent = "ContentContent3", ContentTitle = "ContentTitle3", Title = "Test3",
+            Content = "Content3", Info = "Info3", Query = "Query3", Comment = "Comment3",
+            LessonId = 1
+        });
+        _dbContext.SaveChanges();
+
+        var result = _paragraphDataService.GetParagraphs(1, 2, ParagraphOrderCriteria.ByInfo);
+
+        Assert.Equal(2, result.Count());
+    }
+    
+    [Fact]
+    public void GetParagraphs_OrderedByComment_ReturnsCorrectNumberOfParagraphs()
+    {
+        _dbContext.Lessons.Add(_lesson);
+        _dbContext.SaveChanges();
+
+        _dbContext.Paragraphs.Add(new ParagraphEntity
+        {
+            Id = 1, ContentContent = "ContentContent1", ContentTitle = "ContentTitle1", Title = "Test1",
+            Content = "Content1", Info = "Info1", Query = "Query1", Comment = "Comment1",
+            LessonId = 1
+        });
+        _dbContext.Paragraphs.Add(new ParagraphEntity
+        {
+            Id = 2, ContentContent = "ContentContent2", ContentTitle = "ContentTitl2", Title = "Test2",
+            Content = "Content2", Info = "Info2", Query = "Query2", Comment = "Comment2",
+            LessonId = 1
+        });
+        _dbContext.Paragraphs.Add(new ParagraphEntity
+        {
+            Id = 3, ContentContent = "ContentContent3", ContentTitle = "ContentTitle3", Title = "Test3",
+            Content = "Content3", Info = "Info3", Query = "Query3", Comment = "Comment3",
+            LessonId = 1
+        });
+        _dbContext.SaveChanges();
+
+        var result = _paragraphDataService.GetParagraphs(1, 2, ParagraphOrderCriteria.ByComment);
+
+        Assert.Equal(2, result.Count());
+    }
+    
+    [Fact]
+    public void GetParagraphs_WithBadPage_ReturnsCorrectNumberOfParagraphs()
+    {
+        _dbContext.Lessons.Add(_lesson);
+        _dbContext.SaveChanges();
+
+        _dbContext.Paragraphs.Add(new ParagraphEntity
+        {
+            Id = 1, ContentContent = "ContentContent1", ContentTitle = "ContentTitle1", Title = "Test1",
+            Content = "Content1", Info = "Info1", Query = "Query1", Comment = "Comment1",
+            LessonId = 1
+        });
+        _dbContext.Paragraphs.Add(new ParagraphEntity
+        {
+            Id = 2, ContentContent = "ContentContent2", ContentTitle = "ContentTitl2", Title = "Test2",
+            Content = "Content2", Info = "Info2", Query = "Query2", Comment = "Comment2",
+            LessonId = 1
+        });
+        _dbContext.Paragraphs.Add(new ParagraphEntity
+        {
+            Id = 3, ContentContent = "ContentContent3", ContentTitle = "ContentTitle3", Title = "Test3",
+            Content = "Content3", Info = "Info3", Query = "Query3", Comment = "Comment3",
+            LessonId = 1
+        });
+        _dbContext.SaveChanges();
+
+        var result = _paragraphDataService.GetParagraphs(-42, 2, ParagraphOrderCriteria.None);
+
+        Assert.Equal(2, result.Count());
+    }
+    
+    [Fact]
+    public void GetParagraphs_WithBadNumber_ReturnsCorrectNumberOfParagraphs()
+    {
+        _dbContext.Lessons.Add(_lesson);
+        _dbContext.SaveChanges();
+
+        _dbContext.Paragraphs.Add(new ParagraphEntity
+        {
+            Id = 1, ContentContent = "ContentContent1", ContentTitle = "ContentTitle1", Title = "Test1",
+            Content = "Content1", Info = "Info1", Query = "Query1", Comment = "Comment1",
+            LessonId = 1
+        });
+        _dbContext.Paragraphs.Add(new ParagraphEntity
+        {
+            Id = 2, ContentContent = "ContentContent2", ContentTitle = "ContentTitl2", Title = "Test2",
+            Content = "Content2", Info = "Info2", Query = "Query2", Comment = "Comment2",
+            LessonId = 1
+        });
+        _dbContext.Paragraphs.Add(new ParagraphEntity
+        {
+            Id = 3, ContentContent = "ContentContent3", ContentTitle = "ContentTitle3", Title = "Test3",
+            Content = "Content3", Info = "Info3", Query = "Query3", Comment = "Comment3",
+            LessonId = 1
+        });
+        _dbContext.SaveChanges();
+
+        var result = _paragraphDataService.GetParagraphs(1, -42, ParagraphOrderCriteria.None);
+
+        Assert.Equal(3, result.Count());
+    }
+
+    [Fact]
+    public void GetParagraphById_ReturnsCorrectParagraph()
+    {
+        _dbContext.Lessons.Add(_lesson);
+        _dbContext.SaveChanges();
+
+        _dbContext.Paragraphs.Add(new ParagraphEntity
+        {
+            Id = 1, ContentContent = "ContenContent1", ContentTitle = "ContentTitle1", Title = "Test1",
+            Content = "Content1", Info = "Info1", Query = "Query1", Comment = "Comment1",
+            LessonId = 1
+        });
+        _dbContext.Paragraphs.Add(new ParagraphEntity
+        {
+            Id = 2, ContentContent = "ContenContent2", ContentTitle = "ContentTitle2", Title = "Test2",
+            Content = "Content2", Info = "Info2", Query = "Query2", Comment = "Comment2",
+            LessonId = 1
+        });
+        _dbContext.SaveChanges();
+
+        var result = _paragraphDataService.GetParagraphById(1);
+
+        Assert.Equal("Test1", result.Title);
+    }
+
+    [Fact]
+    public void CreateParagraph_AddsNewParagraph()
+    {
+        _dbContext.Lessons.Add(_lesson);
+        _dbContext.SaveChanges();
+
+        var result = _paragraphDataService.CreateParagraph("ContentTitle", "ContentContent", "Test", "Content", "Info",
+            "Query", "Comment", 1);
+
+        Assert.Equal(1, _dbContext.Paragraphs.Count());
+        Assert.Equal("Test", result.Title);
+    }
+
+    [Fact]
+    public void DeleteParagraph_RemovesParagraph()
+    {
+        _dbContext.Lessons.Add(_lesson);
+        _dbContext.SaveChanges();
+
+        _dbContext.Paragraphs.Add(new ParagraphEntity
+        {
+            Id = 1, ContentContent = "ContenContent1", ContentTitle = "ContentTitle1", Title = "Test1",
+            Content = "Content1", Info = "Info1", Query = "Query1", Comment = "Comment1",
+            LessonId = 1
+        });
+
+        _dbContext.SaveChanges();
+
+        var b = _paragraphDataService.DeleteParagraph(1);
+
+        Assert.Empty(_dbContext.Paragraphs);
+    }
+
+    [Fact]
+    public void UpdateParagraph_UpdatesExistingParagraph()
+    {
+        _dbContext.Lessons.Add(_lesson);
+        _dbContext.SaveChanges();
+
+        _dbContext.Paragraphs.Add(new ParagraphEntity
+        {
+            Id = 1, ContentContent = "ContenContent1", ContentTitle = "ContentTitle1", Title = "Test1",
+            Content = "Content1", Info = "Info1", Query = "Query1", Comment = "Comment1",
+            LessonId = 1
+        });
+        _dbContext.SaveChanges();
+
+        var updatedParagraph = new ParagraphEntity
+        {
+            Id = 1, ContentContent = "ContenContent1", ContentTitle = "ContentTitle1", Title = "Updated",
+            Content = "Content1", Info = "Info1", Query = "Query1", Comment = "Comment1",
+            LessonId = 1
+        };
+        var result = _paragraphDataService.UpdateParagraph(1, updatedParagraph);
+
+        Assert.Equal("Updated", result.Title);
+    }
+}

API_SQLuedo/TestEF/Service/TestSuccessDataService.cs

@@ -0,0 +1,249 @@
+using DbContextLib;
+using DbDataManager.Service;
+using Entities;
+using Microsoft.Data.Sqlite;
+using Microsoft.EntityFrameworkCore;
+using Model.OrderCriteria;
+
+namespace TestEF.Service;
+
+public class TestSuccessDataService
+{
+    private readonly UserDbContext _dbContext;
+    private readonly SuccessDataService _successDataService;
+    private readonly List<UserEntity> _users = new();
+    private readonly List<InquiryEntity> _inquiries = new();
+
+    public TestSuccessDataService()
+    {
+        var connection = new SqliteConnection("DataSource=:memory:");
+        connection.Open();
+        var options = new DbContextOptionsBuilder<UserDbContext>()
+            .UseSqlite(connection)
+            .Options;
+
+        _dbContext = new UserDbContext(options);
+        _successDataService = new SuccessDataService(_dbContext);
+
+        _users.AddRange(new List<UserEntity>
+        {
+            new()
+            {
+                Id = 1,
+                Username = "Pseudo",
+                Password = "Password",
+                Email = "Email@gmail.com",
+                IsAdmin = true
+            },
+            new()
+            {
+                Id = 2,
+                Username = "Pseudo2",
+                Password = "Password2",
+                Email = "Email2@gmail.com",
+                IsAdmin = false
+            },
+            new()
+            {
+                Id = 3,
+                Username = "Pseudo3",
+                Password = "Password3",
+                Email = "Email3@gmail.com",
+                IsAdmin = false
+            }
+        });
+
+        _inquiries.AddRange(new List<InquiryEntity>
+        {
+            new()
+            {
+                Id = 1,
+                Title = "Title",
+                Description = "Description",
+                IsUser = false
+            },
+            new()
+            {
+                Id = 2,
+                Title = "Title2",
+                Description = "Description2",
+                IsUser = true
+            },
+            new()
+            {
+                Id = 3,
+                Title = "Title3",
+                Description = "Description3",
+                IsUser = false
+            }
+        });
+        _dbContext.Users.AddRange(_users);
+        _dbContext.Inquiries.AddRange(_inquiries);
+        _dbContext.SaveChanges();
+    }
+
+    [Fact]
+    public void GetSuccesses_WithoutCriteria_ReturnsCorrectNumberOfSuccesses()
+    {
+        var success1 = new SuccessEntity { UserId = 1, InquiryId = 1, IsFinished = true };
+        var success2 = new SuccessEntity { UserId = 2, InquiryId = 2, IsFinished = false };
+        var success3 = new SuccessEntity { UserId = 3, InquiryId = 3, IsFinished = true };
+
+        _dbContext.Successes.AddRange(success1, success2, success3);
+        _dbContext.SaveChanges();
+
+        var result = _successDataService.GetSuccesses(1, 2, SuccessOrderCriteria.None);
+
+        Assert.Equal(2, result.Count());
+    }
+    
+    [Fact]
+    public void GetSuccesses_OrderedByUserId_ReturnsCorrectNumberOfSuccesses()
+    {
+        var success1 = new SuccessEntity { UserId = 1, InquiryId = 1, IsFinished = true };
+        var success2 = new SuccessEntity { UserId = 2, InquiryId = 2, IsFinished = false };
+        var success3 = new SuccessEntity { UserId = 3, InquiryId = 3, IsFinished = true };
+
+        _dbContext.Successes.AddRange(success1, success2, success3);
+        _dbContext.SaveChanges();
+
+        var result = _successDataService.GetSuccesses(1, 2, SuccessOrderCriteria.ByUserId);
+
+        Assert.Equal(2, result.Count());
+    }
+    
+    [Fact]
+    public void GetSuccesses_OrderedByInquiryId_ReturnsCorrectNumberOfSuccesses()
+    {
+        var success1 = new SuccessEntity { UserId = 1, InquiryId = 1, IsFinished = true };
+        var success2 = new SuccessEntity { UserId = 2, InquiryId = 2, IsFinished = false };
+        var success3 = new SuccessEntity { UserId = 3, InquiryId = 3, IsFinished = true };
+
+        _dbContext.Successes.AddRange(success1, success2, success3);
+        _dbContext.SaveChanges();
+
+        var result = _successDataService.GetSuccesses(1, 2, SuccessOrderCriteria.ByInquiryId);
+
+        Assert.Equal(2, result.Count());
+    }
+    
+    [Fact]
+    public void GetSuccesses_OrderedByIsFinished_ReturnsCorrectNumberOfSuccesses()
+    {
+        var success1 = new SuccessEntity { UserId = 1, InquiryId = 1, IsFinished = true };
+        var success2 = new SuccessEntity { UserId = 2, InquiryId = 2, IsFinished = false };
+        var success3 = new SuccessEntity { UserId = 3, InquiryId = 3, IsFinished = true };
+
+        _dbContext.Successes.AddRange(success1, success2, success3);
+        _dbContext.SaveChanges();
+
+        var result = _successDataService.GetSuccesses(1, 2, SuccessOrderCriteria.ByIsFinished);
+
+        Assert.Equal(2, result.Count());
+    }
+    
+    [Fact]
+    public void GetSuccesses_WithBadPage_ReturnsCorrectNumberOfSuccesses()
+    {
+        var success1 = new SuccessEntity { UserId = 1, InquiryId = 1, IsFinished = true };
+        var success2 = new SuccessEntity { UserId = 2, InquiryId = 2, IsFinished = false };
+        var success3 = new SuccessEntity { UserId = 3, InquiryId = 3, IsFinished = true };
+
+        _dbContext.Successes.AddRange(success1, success2, success3);
+        _dbContext.SaveChanges();
+
+        var result = _successDataService.GetSuccesses(-42, 2, SuccessOrderCriteria.None);
+
+        Assert.Equal(2, result.Count());
+    }
+    
+    [Fact]
+    public void GetSuccesses_WithBadNumber_ReturnsCorrectNumberOfSuccesses()
+    {
+        var success1 = new SuccessEntity { UserId = 1, InquiryId = 1, IsFinished = true };
+        var success2 = new SuccessEntity { UserId = 2, InquiryId = 2, IsFinished = false };
+        var success3 = new SuccessEntity { UserId = 3, InquiryId = 3, IsFinished = true };
+
+        _dbContext.Successes.AddRange(success1, success2, success3);
+        _dbContext.SaveChanges();
+
+        var result = _successDataService.GetSuccesses(1, -42, SuccessOrderCriteria.None);
+
+        Assert.Equal(3, result.Count());
+    }
+
+    [Fact]
+    public void GetSuccessesByUserId_ReturnsCorrectSuccesses()
+    {
+        var success1 = new SuccessEntity { UserId = 1, InquiryId = 1, IsFinished = true };
+        var success2 = new SuccessEntity { UserId = 1, InquiryId = 2, IsFinished = false };
+
+        _dbContext.Successes.AddRange(success1, success2);
+        _dbContext.SaveChanges();
+
+        var result = _successDataService.GetSuccessesByUserId(1);
+
+        Assert.Equal(2, result.Count());
+    }
+/*
+    [Fact]
+    public void GetSuccessesByInquiryId_ReturnsCorrectSuccesses()
+    {
+        _dbContext.Inquiries.Add(
+            new InquiryEntity
+            {
+                Id = 4,
+                Title = "Title3",
+                Description = "Description3",
+                IsUser = false
+            }
+        );
+        _dbContext.SaveChanges();
+
+        var success1 = new SuccessEntity { UserId = 1, InquiryId = 4, IsFinished = true };
+        var success2 = new SuccessEntity { UserId = 2, InquiryId = 4, IsFinished = false };
+
+        _dbContext.Successes.AddRange(success1, success2);
+        _dbContext.SaveChanges();
+
+        var result = _successDataService.GetSuccessesByInquiryId(4);
+
+        Assert.Equal(2, result.Count());
+    }*/
+
+    [Fact]
+    public void DeleteSuccess_RemovesSuccess()
+    {
+        var success = new SuccessEntity { UserId = 1, InquiryId = 1, IsFinished = true };
+
+        _dbContext.Successes.Add(success);
+        _dbContext.SaveChanges();
+
+        _successDataService.DeleteSuccess(1, 1);
+
+        Assert.Empty(_dbContext.Successes);
+    }
+
+    [Fact]
+    public void UpdateSuccess_UpdatesExistingSuccess()
+    {
+        var success = new SuccessEntity { UserId = 1, InquiryId = 1, IsFinished = true };
+
+        _dbContext.Successes.Add(success);
+        _dbContext.SaveChanges();
+
+        var updatedSuccess = new SuccessEntity { UserId = 1, InquiryId = 1, IsFinished = false };
+        var result = _successDataService.UpdateSuccess(1, 1, updatedSuccess);
+
+        Assert.False(result.IsFinished);
+    }
+
+    [Fact]
+    public void CreateSuccess_AddsNewSuccess()
+    {
+        var result = _successDataService.CreateSuccess(1, 3, true);
+
+        Assert.Single(_dbContext.Successes);
+        Assert.True(result.IsFinished);
+    }
+}

API_SQLuedo/TestEF/Service/TestUserDataService.cs

@@ -0,0 +1,298 @@
+using DbContextLib;
+using DbDataManager.Service;
+using Entities;
+using Microsoft.Data.Sqlite;
+using Microsoft.EntityFrameworkCore;
+using Model.OrderCriteria;
+
+namespace TestEF.Service;
+
+public class TestUserDataService
+{
+    private readonly UserDbContext _dbContext;
+    private readonly UserDataService _userDataService;
+
+    public TestUserDataService()
+    {
+        var connection = new SqliteConnection("DataSource=:memory:");
+        connection.Open();
+        var options = new DbContextOptionsBuilder<UserDbContext>()
+            .UseSqlite(connection)
+            .Options;
+
+        _dbContext = new UserDbContext(options);
+        _userDataService = new UserDataService(_dbContext);
+    }
+
+    [Fact]
+    public void GetUsers_ReturnsCorrectNumberOfUsers()
+    {
+        _dbContext.Users.Add(new UserEntity() { Id = 1, Username = "Test10", Email = "example1@email.com", Password = "password", IsAdmin = true });
+        _dbContext.Users.Add(new UserEntity() { Id = 2, Username = "Test12", Email = "example2@email.com", Password = "password", IsAdmin = false });
+        _dbContext.Users.Add(new UserEntity() { Id = 3, Username = "Test13", Email = "example3@email.com", Password = "password", IsAdmin = true });
+        _dbContext.SaveChanges();
+        var result = _userDataService.GetUsers(1, 2, UserOrderCriteria.None);
+        Assert.Equal(2, result.Count());
+    }
+    
+    [Fact]
+    public void GetNotAdminUsers_ReturnsCorrectNumberOfUsers()
+    {
+        _dbContext.Users.Add(new UserEntity() { Id = 1, Username = "Test14", Email = "example4@email.com", Password = "password", IsAdmin = true });
+        _dbContext.Users.Add(new UserEntity() { Id = 2, Username = "Test15", Email = "example5@email.com", Password = "password", IsAdmin = false });
+        _dbContext.Users.Add(new UserEntity() { Id = 3, Username = "Test16", Email = "example6@email.com", Password = "password", IsAdmin = true });
+        _dbContext.SaveChanges();
+        var result = _userDataService.GetNotAdminUsers(1, 2, UserOrderCriteria.None);
+        Assert.Equal(1, result.Count());
+    }
+    
+    [Fact]
+    public void GetNotAdminUsers_BadPage_ReturnsCorrectNumberOfUsers()
+    {
+        _dbContext.Users.Add(new UserEntity() { Id = 1, Username = "Test17", Email = "example7@email.com", Password = "password", IsAdmin = true });
+        _dbContext.Users.Add(new UserEntity() { Id = 2, Username = "Test18", Email = "example8@email.com", Password = "password", IsAdmin = false });
+        _dbContext.Users.Add(new UserEntity() { Id = 3, Username = "Test19", Email = "example9@email.com", Password = "password", IsAdmin = true });
+        _dbContext.SaveChanges();
+        var result = _userDataService.GetNotAdminUsers(-42, 2, UserOrderCriteria.None);
+        Assert.Equal(1, result.Count());
+    }
+    
+    [Fact]
+    public void GetNotAdminUsers_BadNumber_ReturnsCorrectNumberOfUsers()
+    {
+        _dbContext.Users.Add(new UserEntity() { Id = 1, Username = "Test20", Email = "example10@email.com", Password = "password", IsAdmin = true });
+        _dbContext.Users.Add(new UserEntity() { Id = 2, Username = "Test21", Email = "example11@email.com", Password = "password", IsAdmin = false });
+        _dbContext.Users.Add(new UserEntity() { Id = 3, Username = "Test22", Email = "example12@email.com", Password = "password", IsAdmin = true });
+        _dbContext.SaveChanges();
+        var result = _userDataService.GetNotAdminUsers(1, -42, UserOrderCriteria.None);
+        Assert.Equal(1, result.Count());
+    }
+    
+    [Fact]
+    public void GetNotAdminUsers_OrderedById_ReturnsCorrectNumberOfUsers()
+    {
+        _dbContext.Users.Add(new UserEntity() { Id = 1, Username = "Test23", Email = "example13@email.com", Password = "password", IsAdmin = true });
+        _dbContext.Users.Add(new UserEntity() { Id = 2, Username = "Test24", Email = "example14@email.com", Password = "password", IsAdmin = false });
+        _dbContext.Users.Add(new UserEntity() { Id = 3, Username = "Test51", Email = "example15@email.com", Password = "password", IsAdmin = true });
+        _dbContext.SaveChanges();
+        var result = _userDataService.GetNotAdminUsers(1, 2, UserOrderCriteria.ById);
+        Assert.Equal(1, result.Count());
+    }
+    
+    [Fact]
+    public void GetNotAdminUsers_OrderedByUsername_ReturnsCorrectNumberOfUsers()
+    {
+        _dbContext.Users.Add(new UserEntity() { Id = 1, Username = "Test25", Email = "example16@email.com", Password = "password", IsAdmin = true });
+        _dbContext.Users.Add(new UserEntity() { Id = 2, Username = "Test26", Email = "example17@email.com", Password = "password", IsAdmin = false });
+        _dbContext.Users.Add(new UserEntity() { Id = 3, Username = "Test27", Email = "example18@email.com", Password = "password", IsAdmin = true });
+        _dbContext.SaveChanges();
+        var result = _userDataService.GetNotAdminUsers(1, 2, UserOrderCriteria.ByUsername);
+        Assert.Equal(1, result.Count());
+    }
+    
+    [Fact]
+    public void GetNotAdminUsers_OrderedByEmail_ReturnsCorrectNumberOfUsers()
+    {
+        _dbContext.Users.Add(new UserEntity() { Id = 1, Username = "Test52", Email = "example45@email.com", Password = "password", IsAdmin = true });
+        _dbContext.Users.Add(new UserEntity() { Id = 2, Username = "Test53", Email = "example46@email.com", Password = "password", IsAdmin = false });
+        _dbContext.Users.Add(new UserEntity() { Id = 3, Username = "Test54", Email = "example17@email.com", Password = "password", IsAdmin = true });
+        _dbContext.SaveChanges();
+        var result = _userDataService.GetNotAdminUsers(1, 2, UserOrderCriteria.ByEmail);
+        Assert.Equal(1, result.Count());
+    }
+    
+    [Fact]
+    public void GetNotAdminUsers_OrderedByIsAdmin_ReturnsCorrectNumberOfUsers()
+    {
+        _dbContext.Users.Add(new UserEntity() { Id = 1, Username = "Test28", Email = "example19@email.com", Password = "password", IsAdmin = true });
+        _dbContext.Users.Add(new UserEntity() { Id = 2, Username = "Test29", Email = "example20@email.com", Password = "password", IsAdmin = false });
+        _dbContext.Users.Add(new UserEntity() { Id = 3, Username = "Test30", Email = "example21@email.com", Password = "password", IsAdmin = true });
+        _dbContext.SaveChanges();
+        var result = _userDataService.GetNotAdminUsers(1, 2, UserOrderCriteria.ByIsAdmin);
+        Assert.Equal(1, result.Count());
+    }
+    
+    [Fact]
+    public void GetNumberOfUsers_ReturnsCorrectNumberOfUsers()
+    {
+        _dbContext.Users.Add(new UserEntity() { Id = 1, Username = "Test31", Email = "example22@email.com", Password = "password", IsAdmin = true });
+        _dbContext.Users.Add(new UserEntity() { Id = 2, Username = "Test32", Email = "example23@email.com", Password = "password", IsAdmin = false });
+        _dbContext.Users.Add(new UserEntity() { Id = 3, Username = "Test33", Email = "example24@email.com", Password = "password", IsAdmin = true });
+        _dbContext.SaveChanges();
+        var result = _userDataService.GetNumberOfUsers();
+        Assert.Equal(3, result);
+    }
+
+    [Fact]
+    public void GetUserById_ReturnsCorrectUser()
+    {
+        _dbContext.Users.Add(new UserEntity() { Id = 1, Username = "Test34", Email = "example25@email.com", Password = "password", IsAdmin = true });
+        _dbContext.Users.Add(new UserEntity() { Id = 2, Username = "Test35", Email = "example26@email.com", Password = "password", IsAdmin = false });
+        _dbContext.SaveChanges();
+        var result = _userDataService.GetUserById(1);
+        Assert.Equal("Test34", result.Username);
+    }
+
+    [Fact]
+    public void GetUserByUsername_ReturnsCorrectUser()
+    {
+        _dbContext.Users.Add(new UserEntity() { Id = 1, Username = "Test36", Email = "example27@email.com", Password = "password", IsAdmin = true });
+        _dbContext.Users.Add(new UserEntity() { Id = 2, Username = "Test37", Email = "example28@email.com", Password = "password", IsAdmin = false });
+        _dbContext.SaveChanges();
+        var result = _userDataService.GetUserByUsername("Test36");
+        Assert.Equal(1, result.Id);
+    }
+    [Fact]
+    public void GetUserByEmail_ReturnsCorrectUser()
+    {
+        _dbContext.Users.Add(new UserEntity() { Id = 1, Username = "Test38", Email = "example29@email.com", Password = "password", IsAdmin = true });
+        _dbContext.Users.Add(new UserEntity() { Id = 2, Username = "Test39", Email = "example30@email.com", Password = "password", IsAdmin = false });
+        _dbContext.SaveChanges();
+        var result = _userDataService.GetUserByEmail("example29@email.com");
+        Assert.Equal(1, result.Id);
+    }
+
+    [Fact]
+    public void CreateUser_AddsNewUser()
+    {
+        var result = _userDataService.CreateUser("Test42", "password", "eamil@example1.com", true);
+        Assert.Equal(1, _dbContext.Users.Count());
+        Assert.Equal("Test42", result.Username);
+    }
+
+    [Fact]
+    public void DeleteUser_RemovesUser()
+    {
+        _dbContext.Users.Add(new UserEntity() { Id = 1, Username = "Test1", Email = "example@email.com", Password = "password", IsAdmin = true });
+        _dbContext.SaveChanges();
+        _userDataService.DeleteUser(1);
+        Assert.Empty(_dbContext.Inquiries);
+    }
+    
+    [Fact]
+    public void DeleteUserByUsername_RemovesUser()
+    {
+        _dbContext.Users.Add(new UserEntity() { Id = 1, Username = "Test1", Email = "example@email.com", Password = "password", IsAdmin = true });
+        _dbContext.SaveChanges();
+        _userDataService.DeleteUserByUsername("Test1");
+        Assert.Empty(_dbContext.Inquiries);
+    }
+
+    [Fact]
+    public void UpdateUser_UpdatesExistingUser()
+    {
+        _dbContext.Users.Add(new UserEntity() { Id = 1, Username = "Test1", Email = "example@email.com", Password = "password", IsAdmin = true });
+        _dbContext.SaveChanges();
+
+        var updatedUser = new UserEntity() { Id = 1, Username = "Updated", Email = "updated@example.com", Password = "updated", IsAdmin = false };
+        var result = _userDataService.UpdateUser(1, updatedUser);
+
+        Assert.Equal("Updated", result.Username);
+        Assert.Equal("updated@example.com", result.Email);
+        Assert.Equal("updated", result.Password);
+        Assert.False(result.IsAdmin);
+    }
+
+    [Fact]
+    public void GetUsers_WithBadPage_ReturnsClassicUsers()
+    {
+        _dbContext.Users.Add(new UserEntity() { Id = 1, Username = "Test40", Email = "example31@email.com", Password = "password", IsAdmin = true });
+        _dbContext.Users.Add(new UserEntity() { Id = 2, Username = "Test41", Email = "example32@email.com", Password = "password", IsAdmin = false });
+        _dbContext.SaveChanges();
+
+        var result = _userDataService.GetUsers(-1, 2, UserOrderCriteria.None);
+
+        Assert.Equal(2, result.Count());
+    }
+    
+    [Fact]
+    public void GetUsers_WithBadNumber_ReturnsClassicUsers()
+    {
+        _dbContext.Users.Add(new UserEntity() { Id = 1, Username = "Test43", Email = "example33@email.com", Password = "password", IsAdmin = true });
+        _dbContext.Users.Add(new UserEntity() { Id = 2, Username = "Test44", Email = "example34@email.com", Password = "password", IsAdmin = false });
+        _dbContext.SaveChanges();
+
+        var result = _userDataService.GetUsers(1, -42, UserOrderCriteria.None);
+
+        Assert.Equal(2, result.Count());
+    }
+
+    [Fact]
+    public void GetUserById_WithoutId_ThrowsException()
+    {
+        _dbContext.Users.Add(new UserEntity() { Id = 1, Username = "Test1", Email = "example@email.com", Password = "password", IsAdmin = true });
+        _dbContext.SaveChanges();
+        Assert.Throws<ArgumentException>(() => _userDataService.GetUserById(2));
+    }
+
+    [Fact]
+    public void GetUserByUsername_WithoutUsername_ThrowsException()
+    {
+        _dbContext.Users.Add(new UserEntity() { Id = 1, Username = "Test1", Email = "example@email.com", Password = "password", IsAdmin = true });
+        _dbContext.SaveChanges();
+
+        Assert.Throws<ArgumentException>(() => _userDataService.GetUserByUsername("Test2"));
+    }
+    
+    [Fact]
+    public void GetUserByEmail_WithoutUsername_ThrowsException()
+    {
+        _dbContext.Users.Add(new UserEntity() { Id = 1, Username = "Test1", Email = "example@email.com", Password = "password", IsAdmin = true });
+        _dbContext.SaveChanges();
+
+        Assert.Throws<ArgumentException>(() => _userDataService.GetUserByEmail("test@test"));
+    }
+
+    [Fact]
+    public void DeleteUser_WithoutId_ReturnsFalse()
+    {
+        _dbContext.Users.Add(new UserEntity() { Id = 1, Username = "Test1", Email = "example@email.com", Password = "password", IsAdmin = true });
+        _dbContext.SaveChanges();
+
+        var result = _userDataService.DeleteUser(2);
+
+        Assert.False(result);
+    }
+    [Fact]
+    public void isEmailTaken_ReturnFalse()
+    {
+        _dbContext.Users.Add(new UserEntity() { Id = 1, Username = "Test81", Email = "example81@email.com", Password = "password", IsAdmin = true });
+        _dbContext.SaveChanges();
+
+        var result = _userDataService.IsEmailTaken("example895@email.com");
+
+        Assert.False(result);
+    }
+    [Fact]
+    public void isEmailTaken_ReturnTrue()
+    {
+        _dbContext.Users.Add(new UserEntity() { Id = 1, Username = "Test82", Email = "example82@email.com", Password = "password", IsAdmin = true });
+        _dbContext.SaveChanges();
+
+        var result = _userDataService.IsEmailTaken("example82@email.com");
+
+        Assert.True(result);
+    }
+    
+    [Fact]
+    public void DeleteUserByUsername_WithoutExisting_ReturnsFalse()
+    {
+        _dbContext.Users.Add(new UserEntity() { Id = 1, Username = "Test1", Email = "example@email.com", Password = "password", IsAdmin = true });
+        _dbContext.SaveChanges();
+
+        var result = _userDataService.DeleteUserByUsername("Test2");
+
+        Assert.False(result);
+    }
+
+    [Fact]
+    public void UpdateUser_WithoutId_ThrowsException()
+    {
+        _dbContext.Users.Add(new UserEntity() { Id = 1, Username = "Test1", Email = "example@email.com", Password = "password", IsAdmin = true });
+        _dbContext.SaveChanges();
+
+        var updatedUser = new UserEntity() { Id = 1, Username = "Updated", Email = "updated@email.com", Password = "updated", IsAdmin = false };
+
+        Assert.Throws<ArgumentException>(() => _userDataService.UpdateUser(2, updatedUser));
+    }
+}