Merge branch 'master' of codefirst.iut.uca.fr:johnny.ratton/API_SQLuedo

API_SQLuedo/.dockerignore

@@ -0,0 +1,30 @@
+**/.classpath
+**/.dockerignore
+**/.env
+**/.git
+**/.gitignore
+**/.project
+**/.settings
+**/.toolstarget
+**/.vs
+**/.vscode
+**/*.*proj.user
+**/*.dbmdl
+**/*.jfm
+**/azds.yaml
+**/bin
+**/charts
+**/docker-compose*
+**/Dockerfile*
+**/node_modules
+**/npm-debug.log
+**/obj
+**/secrets.dev.yaml
+**/values.dev.yaml
+LICENSE
+README.md
+!**/.gitignore
+!.git/HEAD
+!.git/config
+!.git/packed-refs
+!.git/refs/heads/**

API_SQLuedo/API/Controllers/UserController.cs

@@ -150,6 +150,8 @@ namespace API.Controllers
         [HttpPost]
         [ProducesResponseType(typeof(UserDto), 201)]
         [ProducesResponseType(typeof(string), 400)]
+        [ProducesResponseType(typeof(string), 409)]
+        [ProducesResponseType(typeof(string), 410)]
         public IActionResult CreateUser([FromBody] UserDto dto)
         {
             if (dto.Username == null || dto.Password == null || dto.Email == null)
@@ -179,9 +181,10 @@ namespace API.Controllers
         [ProducesResponseType(typeof(UserDto), 200)]
         [ProducesResponseType(typeof(string), 400)]
         [ProducesResponseType(typeof(string), 404)]
-        public IActionResult UpdateUser(int id, [FromBody] UserDto UserDto)
+        [ProducesResponseType(typeof(string), 409)]
+        public IActionResult UpdateUser(int id, [FromBody] UserDto userDto)
         {
-            if (id != UserDto.Id)
+            if (id != userDto.Id)
             {
                 logger.LogError("[ERREUR] Problème ID - La mise à jour de l'utilisateur avec l'id {id} a échouée.", id);
                 return BadRequest();
@@ -194,15 +197,37 @@ namespace API.Controllers
                 return BadRequest();
             }
 
-            if (UserDto != null)
+            if (userDto.Username == userService.GetUserById(id).Username && !userService.IsEmailTaken(userDto.Email)
+                || (userDto.Email == userService.GetUserById(id).Email &&
+                    !userService.IsUsernameTaken(userDto.Username))
+                || (!userService.IsEmailTaken(userDto.Email) && !userService.IsUsernameTaken(userDto.Username)))
             {
                 logger.LogInformation("[INFORMATION] La mise à jour de l'utilisateur avec l'id {id} a été effectuée",
                     id);
-                return Ok(userService.UpdateUser(id, UserDto));
+                return Ok(userService.UpdateUser(id, userDto));
             }
+            logger.LogError("[ERREUR] Email ou nom d'utilisateur déjà utilisé");
+            return StatusCode(409,"Email ou nom d'utilisateur déjà utilisé");
+        }
 
-            logger.LogError("[ERREUR] Aucun utilisateur trouvé avec l'id {id}.", id);
+        [HttpPut("user/promote/{id:int}")]
-            return NotFound();
+        [ProducesResponseType(typeof(UserDto), 200)]
+        [ProducesResponseType(typeof(string), 404)]
+        public IActionResult PromoteUser(int id)
+        {
+            var userPromoted = userService.GetUserById(id);
+            if (userPromoted != null)
+            {
+                userPromoted = userService.PromoteUser(id);
+                logger.LogInformation("[INFORMATION] La promotion de l'utilisateur avec l'id {id} a été effectuée");
+                return Ok(userPromoted);
+            }
+            else
+            {
+                logger.LogInformation("[INFORMATION] La promotion de l'utilisateur avec l'id {id} à échouée",
+                    id);
+                return NotFound();
+            }
         }
     }
 }

API_SQLuedo/API/Dockerfile

@@ -0,0 +1,32 @@
+#See https://aka.ms/customizecontainer to learn how to customize your debug container and how Visual Studio uses this Dockerfile to build your images for faster debugging.
+
+FROM mcr.microsoft.com/dotnet/aspnet:8.0 AS base
+USER app
+WORKDIR /app
+EXPOSE 8080
+EXPOSE 8081
+
+FROM mcr.microsoft.com/dotnet/sdk:8.0 AS build
+ARG BUILD_CONFIGURATION=Release
+WORKDIR /src
+COPY ["API/API.csproj", "API/"]
+COPY ["DbContextLib/DbContextLib.csproj", "DbContextLib/"]
+COPY ["EntityFramework/Entities.csproj", "EntityFramework/"]
+COPY ["Dto/Dto.csproj", "Dto/"]
+COPY ["DbDataManager/DbDataManager.csproj", "DbDataManager/"]
+COPY ["Model/Model.csproj", "Model/"]
+COPY ["Shared/Shared.csproj", "Shared/"]
+COPY ["StubbedContextLib/StubbedContextLib.csproj", "StubbedContextLib/"]
+RUN dotnet restore "./API/./API.csproj"
+COPY . .
+WORKDIR "/src/API"
+RUN dotnet build "./API.csproj" -c $BUILD_CONFIGURATION -o /app/build
+
+FROM build AS publish
+ARG BUILD_CONFIGURATION=Release
+RUN dotnet publish "./API.csproj" -c $BUILD_CONFIGURATION -o /app/publish /p:UseAppHost=false
+
+FROM base AS final
+WORKDIR /app
+COPY --from=publish /app/publish .
+ENTRYPOINT ["dotnet", "API.dll"]

API_SQLuedo/API/Program.cs

@@ -91,9 +91,22 @@ builder.Services.AddSwaggerGen(option =>
         }
     });
 });
+builder.Services.AddCors(options =>
+{
+    options.AddPolicy("AllowSpecificOrigin",
+        builder =>
+        {
+            builder.WithOrigins("https://localhost:7171")
+                .AllowAnyMethod()
+                .AllowAnyHeader(); 
+        });
+});
+
 
 var app = builder.Build();
 
+app.UseCors("AllowSpecificOrigin");
+
 // Création de l'utilisateur admin pour la base de données Identity
 
 using (var scope = app.Services.CreateScope())

API_SQLuedo/API/Service/UserDataServiceAPI.cs

@@ -42,4 +42,7 @@ public class UserDataServiceApi(IUserService<UserEntity> userService) : IUserSer
     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/DbDataManager/Service/InquiryDataService.cs

@@ -26,7 +26,7 @@ public class InquiryDataService : IInquiryService<InquiryEntity>
         {
             number = 10;
         }
-        IQueryable<InquiryEntity> query = DbContext.Inquiries.Skip((page - 1) * number).Take(number);
+        IQueryable<InquiryEntity> query = DbContext.Inquiries;
         switch (orderCriteria)
         {
             case InquiryOrderCriteria.None:
@@ -40,10 +40,14 @@ public class InquiryDataService : IInquiryService<InquiryEntity>
             case InquiryOrderCriteria.ByIsUser:
                 query = query.OrderBy(s => s.IsUser);
                 break;
+            case InquiryOrderCriteria.ById:
+                query = query.OrderBy(s => s.Id);
+                break;
             default:
                 break;
         }
 
+        query = query.Skip((page - 1) * number).Take(number);
         var inquiries = query.ToList();
         return inquiries;
     }
@@ -97,7 +101,7 @@ public class InquiryDataService : IInquiryService<InquiryEntity>
         }
 
         DbContext.Inquiries.Remove(inquiryEntity);
-        DbContext.SaveChangesAsync();
+        DbContext.SaveChanges();
         return true;
     }
 

API_SQLuedo/DbDataManager/Service/LessonDataService.cs

@@ -29,7 +29,7 @@ public class LessonDataService : ILessonService<LessonEntity>
             number = 10;
         }
 
-        IQueryable<LessonEntity> query = DbContext.Lessons.Skip((page - 1) * number).Take(number);
+        IQueryable<LessonEntity> query = DbContext.Lessons;
         switch (orderCriteria)
         {
             case LessonOrderCriteria.None:
@@ -43,10 +43,16 @@ public class LessonDataService : ILessonService<LessonEntity>
             case LessonOrderCriteria.ByLastEdit:
                 query = query.OrderBy(s => s.LastEdit);
                 break;
+            case LessonOrderCriteria.ById:
+                query = query.OrderBy(s => (int) s.Id);
+                break;
             default:
                 break;
         }
 
+        query = query.Skip((page - 1) * number).Take(number);
+        
+
         var lessons = query.ToList();
         return lessons;
     }

API_SQLuedo/DbDataManager/Service/UserDataService.cs

@@ -58,7 +58,8 @@ public class UserDataService : IUserService<UserEntity>
         {
             number = 10;
         }
-        IQueryable<UserEntity> query = DbContext.Users.Skip((page - 1) * number).Take(number);
+
+        IQueryable<UserEntity> query = DbContext.Users;
         switch (orderCriteria)
         {
             case UserOrderCriteria.None:
@@ -78,6 +79,7 @@ public class UserDataService : IUserService<UserEntity>
             default:
                 break;
         }
+        query = query.Skip((page - 1) * number).Take(number);
 
         var users = query.ToList();
         return users;
@@ -190,4 +192,12 @@ public class UserDataService : IUserService<UserEntity>
         var isUsername = DbContext.Users.Any(u => u.Username == username);
         return isUsername;
     }
+
+    public UserEntity PromoteUser(int id)
+    {
+        var userEdit = GetUserById(id);
+        var newUserEntity = UpdateUser(id,new UserEntity{Id = id,Username = userEdit.Username,Password = userEdit.Password,Email = userEdit.Email,IsAdmin = true});
+        DbContext.SaveChangesAsync();
+        return newUserEntity;
+    }
 }

API_SQLuedo/Model/OrderCriteria/InquiryOrderCriteria.cs

@@ -5,5 +5,6 @@ public enum InquiryOrderCriteria
     None,
     ByTitle,
     ByDescription,
-    ByIsUser
+    ByIsUser,
+    ById
 }

API_SQLuedo/Model/OrderCriteria/LessonOrderCriteria.cs

@@ -5,5 +5,6 @@ public enum LessonOrderCriteria
     None,
     ByTitle,
     ByLastPublisher,
-    ByLastEdit
+    ByLastEdit,
+    ById
 }

API_SQLuedo/Shared/IUserService.cs

@@ -16,5 +16,6 @@ namespace Shared
         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/TestAPI/SuccessesUnitTest.cs

@@ -1,6 +1,7 @@
 using API.Controllers;
 using Dto;
 using Microsoft.AspNetCore.Mvc;
+using Microsoft.AspNetCore.Routing;
 using Microsoft.Extensions.Logging.Abstractions;
 using Moq;
 using Shared;
@@ -40,14 +41,30 @@ public class SuccessesUnitTest
     }
 
     [Fact]
-    public void GetSuccessesListFail()
+    public void GetSuccessesListFail_When_Result_Equal_0()
     {
         _successService.Setup(x => x.GetSuccesses(1, 4, 0))
             .Returns(new List<SuccessDto>());
         var successesController =
             new SuccessesController(_successService.Object, new NullLogger<SuccessesController>());
 
-        var successesResult = successesController.GetSuccesses(2, 3, 0);
+        var successesResult = successesController.GetSuccesses(26373, 31771, 0);
+
+        if (successesResult is StatusCodeResult statusCodeResult && statusCodeResult.StatusCode == 204)
+        {
+            Assert.IsNotType<OkObjectResult>(successesResult);
+        }
+    }
+
+    [Fact]
+    public void GetSuccessesListFail_When_Page_Is_A_Negative()
+    {
+        _successService.Setup(x => x.GetSuccesses(1, 4, 0))
+            .Returns(new List<SuccessDto>());
+        var successesController =
+            new SuccessesController(_successService.Object, new NullLogger<SuccessesController>());
+
+        var successesResult = successesController.GetSuccesses(-1, 3, 0);
 
         if (successesResult is StatusCodeResult statusCodeResult && statusCodeResult.StatusCode == 204)
         {
@@ -89,7 +106,7 @@ public class SuccessesUnitTest
     }
 
     [Fact]
-    public void GetSuccessInquiryIdFail()
+    public void GetSuccessInquiryIdFail_When_Id_Not_Exist()
     {
         var successesList = GetSuccessesData();
         _successService.Setup(x => x.GetSuccessesByInquiryId(1))
@@ -108,6 +125,26 @@ public class SuccessesUnitTest
         }
     }
 
+    [Fact]
+    public void GetSuccessInquiryIdFail_When_Id_Negative()
+    {
+        var successesList = GetSuccessesData();
+        _successService.Setup(x => x.GetSuccessesByInquiryId(1))
+            .Returns(new List<SuccessDto> { successesList[0], successesList[1] });
+        var successesController =
+            new SuccessesController(_successService.Object, new NullLogger<SuccessesController>());
+
+        var sucessesResult = successesController.GetSuccessByInquiryId(-1);
+        if (sucessesResult is NotFoundObjectResult nfObjectResult)
+        {
+            var valeur = nfObjectResult.Value;
+
+            Assert.NotNull(valeur);
+            Assert.IsNotType<SuccessDto>(valeur);
+            Assert.DoesNotContain(valeur, successesList);
+        }
+    }
+
     [Fact]
     public void GetSuccessUserIdSuccess()
     {
@@ -140,7 +177,7 @@ public class SuccessesUnitTest
     }
 
     [Fact]
-    public void GetSuccessUserIdFail()
+    public void GetSuccessUserIdFail_When_Id_Not_Found()
     {
         var successesList = GetSuccessesData();
         _successService.Setup(x => x.GetSuccessesByUserId(2))
@@ -159,6 +196,27 @@ public class SuccessesUnitTest
         }
     }
 
+
+    [Fact]
+    public void GetSuccessUserIdFail_When_Id_Negative()
+    {
+        var successesList = GetSuccessesData();
+        _successService.Setup(x => x.GetSuccessesByUserId(2))
+            .Returns(new List<SuccessDto> { successesList[2], successesList[3] });
+        var successesController =
+            new SuccessesController(_successService.Object, new NullLogger<SuccessesController>());
+
+        var sucessesResult = successesController.GetSuccessByUserId(-1);
+        if (sucessesResult is NotFoundObjectResult nfObjectResult)
+        {
+            var valeur = nfObjectResult.Value;
+
+            Assert.NotNull(valeur);
+            Assert.IsNotType<SuccessDto>(valeur);
+            Assert.DoesNotContain(valeur, successesList);
+        }
+    }
+
     [Fact]
     public void DeleteSuccessSuccess()
     {
@@ -177,7 +235,7 @@ public class SuccessesUnitTest
     }
 
     [Fact]
-    public void DeleteSuccessFail()
+    public void DeleteSuccessFail_When_Not_Found()
     {
         _successService.Setup(x => x.DeleteSuccess(1, 1))
             .Returns(true);
@@ -192,6 +250,22 @@ public class SuccessesUnitTest
         }
     }
 
+    [Fact]
+    public void DeleteSuccessFail_When_Negative()
+    {
+        _successService.Setup(x => x.DeleteSuccess(1, 1))
+            .Returns(true);
+        var successesController =
+            new SuccessesController(_successService.Object, new NullLogger<SuccessesController>());
+
+        var sucessesResult = successesController.DeleteSuccess(-1, 278);
+        if (sucessesResult is NotFoundObjectResult nfObjectResult)
+        {
+            Assert.Null(nfObjectResult.Value);
+            Assert.IsNotType<bool>(nfObjectResult.Value);
+        }
+    }
+
     [Fact]
     public void CreateSuccessSuccess()
     {
@@ -213,7 +287,7 @@ public class SuccessesUnitTest
     }
 
     [Fact]
-    public void CreateSuccessFail()
+    public void CreateSuccessFail_When_Id_Not_Found()
     {
         _successService.Setup(x => x.CreateSuccess(8, 8, true))
             .Returns(new SuccessDto(8, 8, true));
@@ -228,6 +302,22 @@ public class SuccessesUnitTest
         }
     }
 
+    [Fact]
+    public void CreateSuccessFail_When_Id_Negative()
+    {
+        _successService.Setup(x => x.CreateSuccess(8, 8, true))
+            .Returns(new SuccessDto(8, 8, true));
+        var successesController =
+            new SuccessesController(_successService.Object, new NullLogger<SuccessesController>());
+
+        var successesResult = successesController.CreateSuccess(new SuccessDto(-1, 818, true));
+
+        if (successesResult is BadRequestResult bdObjectResult)
+        {
+            Assert.Equal(400, bdObjectResult.StatusCode);
+        }
+    }
+
     [Fact]
     public void UpdateSuccessSuccess()
     {
@@ -249,7 +339,7 @@ public class SuccessesUnitTest
     }
 
     [Fact]
-    public void UpdateSuccessFail()
+    public void UpdateSuccessFail_When_Ids_Are_Differents()
     {
         _successService.Setup(x => x.UpdateSuccess(1, 1, new SuccessDto(1, 2, true)))
             .Returns(new SuccessDto(1, 2, true));
@@ -264,6 +354,40 @@ public class SuccessesUnitTest
         }
     }
 
+    [Fact]
+    public void UpdateSuccessFail_When_Id_Negative()
+    {
+        _successService.Setup(x => x.UpdateSuccess(1, 1, new SuccessDto(1, 2, true)))
+            .Returns(new SuccessDto(1, 2, true));
+        var successesController =
+            new SuccessesController(_successService.Object, new NullLogger<SuccessesController>());
+
+        var successesResult = successesController.UpdateSuccess(-2, 1, new SuccessDto(1, 2, true));
+
+        if (successesResult is BadRequestResult bdObjectResult)
+        {
+            Assert.Equal(400, bdObjectResult.StatusCode);
+        }
+    }
+
+    [Fact]
+    public void UpdateSuccessFail_When_Id_Not_Found()
+    {
+        _successService.Setup(x => x.UpdateSuccess(1, 1, new SuccessDto(1, 2, true)))
+            .Returns(new SuccessDto(1, 2, true));
+        var successesController =
+            new SuccessesController(_successService.Object, new NullLogger<SuccessesController>());
+
+        var successesResult = successesController.UpdateSuccess(1000, 1000, new SuccessDto(1000, 1000, true));
+
+        if (successesResult is BadRequestResult bdObjectResult)
+        {
+            Assert.Equal(400, bdObjectResult.StatusCode);
+        }
+    }
+
+
+
     private List<SuccessDto> GetSuccessesData()
     {
         List<SuccessDto> successesData = new List<SuccessDto>(4)

API_SQLuedo/TestAPI/UserUnitTest.cs

@@ -18,7 +18,7 @@ public class UserUnitTest
     }
 
     [Fact]
-    public void GetNumberOfUsers()
+    public void GetNumberOfUsersSuccess()
     {
         var userList = GetUsersData();
         _userService.Setup(x => x.GetNumberOfUsers())
@@ -29,12 +29,30 @@ public class UserUnitTest
 
         if (userResult is OkObjectResult okObjectResult)
         {
-            var valeur = (okObjectResult.Value as KeyValuePair<string,int>?);
+            var valeur = (okObjectResult.Value as KeyValuePair<string, int>?);
             Assert.NotNull(valeur);
             Assert.Equal(userList.Count, valeur.Value.Value);
         }
     }
 
+
+    [Fact]
+    public void GetNumberOfUsers_Fail_Cause_Not_Found()
+    {
+        var userList = GetUsersData();
+        _userService.Setup(x => x.GetNumberOfUsers())
+            .Returns(0);
+        var usersController = new UsersController(new NullLogger<UsersController>(), _userService.Object);
+
+        var userResult = usersController.GetNumberOfUsers();
+
+        if (userResult is StatusCodeResult statusCodeResult && statusCodeResult.StatusCode == 204)
+
+        {
+            Assert.IsNotType<OkObjectResult>(userResult);
+        }
+    }
+
     [Fact]
     public void GetUsersListSuccess()
     {
@@ -55,6 +73,22 @@ public class UserUnitTest
         }
     }
 
+    [Fact]
+    public void GetUserListFail()
+    {
+        _userService.Setup(x => x.GetUsers(1, 4, 0))
+            .Returns(new List<UserDto>());
+        var usersController = new UsersController(new NullLogger<UsersController>(), _userService.Object);
+
+        var userResult = usersController.GetUsers(2, 3, 0);
+
+        if (userResult is StatusCodeResult statusCodeResult && statusCodeResult.StatusCode == 204)
+
+        {
+            Assert.IsNotType<OkObjectResult>(userResult);
+        }
+    }
+
     [Fact]
     public void GetNotAdminUsersListSuccess()
     {
@@ -65,29 +99,31 @@ public class UserUnitTest
 
         var userResult = usersController.GetNotAdminUsers(1, 4, 0);
 
-        if (userResult is OkObjectResult okObjectResult)
+        if (userResult is StatusCodeResult statusCodeResult && statusCodeResult.StatusCode == 204)
-        {
-            var valeur = okObjectResult.Value;
 
-            Assert.NotNull(valeur);
+        {
-            Assert.Equal(GetUsersData().ToString(), valeur.ToString());
+            Assert.IsNotType<OkObjectResult>(userResult);
-            Assert.True(userList.Where(u => u.IsAdmin == false).SequenceEqual(valeur as IEnumerable<UserDto>, new UserIdEqualityComparer()));
         }
     }
 
     [Fact]
-    public void GetUserListFail()
+    public void GetNotAdminUsersListFail_Cause_Not_Found()
     {
-        _userService.Setup(x => x.GetUsers(1, 4, 0))
+        var userList = GetUsersData();
-            .Returns(new List<UserDto>());
+        _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.GetUsers(2, 3, 0);
+        var userResult = usersController.GetNotAdminUsers(100, 4, 0);
-
-        if (userResult is StatusCodeResult statusCodeResult && statusCodeResult.StatusCode == 204)
 
+        if (userResult is OkObjectResult okObjectResult)
         {
-            Assert.IsNotType<OkObjectResult>(userResult);
+            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()));
         }
     }
 
@@ -115,7 +151,7 @@ public class UserUnitTest
     }
 
     [Fact]
-    public void GetUserIdFail()
+    public void GetUserIdFail_Id_Doesnt_Exist()
     {
         var userList = GetUsersData();
         _userService.Setup(x => x.GetUserById(1))
@@ -133,6 +169,26 @@ public class UserUnitTest
         }
     }
 
+
+    [Fact]
+    public void GetUserIdFail__Argument_Exception_Negative_Id()
+    {
+        var userList = GetUsersData();
+        _userService.Setup(x => x.GetUserById(1))
+            .Returns(userList[1]);
+        var usersController = new UsersController(new NullLogger<UsersController>(), _userService.Object);
+
+        var userResult = usersController.GetUserById(-1);
+        if (userResult is NotFoundObjectResult nfObjectResult)
+        {
+            var valeur = nfObjectResult.Value;
+
+            Assert.NotNull(valeur);
+            Assert.IsNotType<UserDto>(valeur);
+            Assert.DoesNotContain(valeur, userList);
+        }
+    }
+
     [Fact]
     public void GetUserUsernameSuccess()
     {
@@ -155,6 +211,7 @@ public class UserUnitTest
             Assert.True(valeur.IsAdmin);
         }
     }
+
     [Fact]
     public void GetUserEmailSuccess()
     {
@@ -198,6 +255,7 @@ public class UserUnitTest
             Assert.False(userList == valeur);
         }
     }
+
     [Fact]
     public void GetUserEmailFail()
     {
@@ -271,7 +329,7 @@ public class UserUnitTest
     }
 
     [Fact]
-    public void CreateUserFail()
+    public void CreateUserFail_When_Field_Null()
     {
         GetUsersData();
         _userService.Setup(x => x.CreateUser("Nom", "Passssss", "heudfk@hdye.com", true))
@@ -285,6 +343,8 @@ public class UserUnitTest
             Assert.Equal(400, bdObjectResult.StatusCode);
         }
     }
+
+
     [Fact]
     public void CreateUserWithExistingEmail()
     {
@@ -293,22 +353,23 @@ public class UserUnitTest
             .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));
+        var userResult = usersController.CreateUser(new UserDto("user", "Passssss", "adressemail@gmail.com", true));
 
         if (userResult is BadRequestResult bdObjectResult)
         {
-            Assert.Equal(400, bdObjectResult.StatusCode);
+            Assert.Equal(409, bdObjectResult.StatusCode);
         }
     }
+
     [Fact]
     public void CreateUserWithExistingUsername()
     {
         GetUsersData();
-        _userService.Setup(x => x.CreateUser("Useruser", "Passssss", "heudfk@hdye.com", true))
+        _userService.Setup(x => x.CreateUser("Nom", "Passssss", "adressemail@gmail.com", true))
-            .Returns(new UserDto("Useruser", "Passssss", "heudfk@hdye.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("Useruser", "Passssss", "heudfk@hdye.com", true));
+        var userResult = usersController.CreateUser(new UserDto("Useruser", "Passssss", "adressemail@gmail.com", true));
 
         if (userResult is BadRequestResult bdObjectResult)
         {
@@ -350,6 +411,154 @@ public class UserUnitTest
             Assert.Equal(400, bdObjectResult.StatusCode);
         }
     }
+    [Fact]
+    public void UpdateUserFailWithExistingUsername()
+    {
+        _userService.Setup(x => x.IsUsernameTaken("Useruser")).Returns(true);
+        _userService.Setup(x => x.IsEmailTaken("heudfk@hdye.com")).Returns(false);
+        _userService.Setup(x => x.GetUserById(1)).Returns(new UserDto(1, "Leuser", "motdepasse", "deuxadresse@gmail.com", true));
+        _userService.Setup(x => x.UpdateUser(1, new UserDto(1, "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.UpdateUser(1, new UserDto(1,"Useruser", "Passssss", "heudfk@hdye.com", true));
+
+        if (userResult is StatusCodeResult statusCodeResult)
+        {
+            Assert.Equal(409, statusCodeResult.StatusCode);
+        }
+    }
+    [Fact]
+    public void UpdateUserFailWithExistingEmail()
+    {
+        _userService.Setup(x => x.IsUsernameTaken("Test1234")).Returns(false);
+        _userService.Setup(x => x.IsEmailTaken("adressemail@gmail.com")).Returns(true);
+        _userService.Setup(x => x.GetUserById(1)).Returns(new UserDto(1, "Leuser", "motdepasse", "deuxadresse@gmail.com", true));
+        _userService.Setup(x => x.UpdateUser(1, new UserDto(1, "Test1234", "Passssss", "adressemail@gmail.com", true)))
+            .Returns(new UserDto("Test1234", "Passssss", "adressemail@gmail.com", true));
+
+        var usersController = new UsersController(new NullLogger<UsersController>(), _userService.Object);
+
+        var userResult = usersController.UpdateUser(1, new UserDto(1,"Test1234", "Passssss", "adressemail@gmail.com", true));
+
+        if (userResult is StatusCodeResult statusCodeResult)
+        {
+            Assert.Equal(409, statusCodeResult.StatusCode);
+        }
+    }
+    [Fact]
+    public void UpdateUserFailWithExistingEmailAndExistingUsername()
+    {
+        _userService.Setup(x => x.IsUsernameTaken("Useruser")).Returns(true);
+        _userService.Setup(x => x.IsEmailTaken("adressemail@gmail.com")).Returns(true);
+        _userService.Setup(x => x.GetUserById(1)).Returns(new UserDto(1, "Leuser", "motdepasse", "deuxadresse@gmail.com", true));
+        _userService.Setup(x => x.UpdateUser(1, new UserDto(1, "Useruser", "Passssss", "adressemail@gmail.com", true)))
+            .Returns(new UserDto("Useruser", "Passssss", "adressemail@gmail.com", true));
+
+        var usersController = new UsersController(new NullLogger<UsersController>(), _userService.Object);
+
+        var userResult = usersController.UpdateUser(1, new UserDto(1,"Useruser", "Passssss", "adressemail@gmail.com", true));
+
+        if (userResult is StatusCodeResult statusCodeResult)
+        {
+            Assert.Equal(409, statusCodeResult.StatusCode);
+        }
+    }
+    [Fact]
+    public void UpdateUserSucessWithSameEmail()
+    {
+        _userService.Setup(x => x.IsUsernameTaken("Test1234")).Returns(false);
+        _userService.Setup(x => x.IsEmailTaken("deuxadresse@gmail.com")).Returns(true);
+        _userService.Setup(x => x.GetUserById(1)).Returns(new UserDto(1, "Leuser", "motdepasse", "deuxadresse@gmail.com", true));
+        _userService.Setup(x => x.UpdateUser(1, new UserDto(1, "Test1234", "Passssss", "deuxadresse@gmail.com", true)))
+            .Returns(new UserDto("Test1234", "Passssss", "deuxadresse@gmail.com", true));
+
+        var usersController = new UsersController(new NullLogger<UsersController>(), _userService.Object);
+
+        var userResult = usersController.UpdateUser(1, new UserDto(1,"Test1234", "Passssss", "deuxadresse@gmail.com", true));
+        if (userResult is OkObjectResult okObjectResult)
+        {
+            UserDto valeur = okObjectResult.Value as UserDto;
+
+            Assert.NotNull(valeur);
+            Assert.Equal("Test1234", valeur.Username);
+            Assert.Equal("Passssss", valeur.Password);
+            Assert.Equal("deuxadresse@gmail.com", valeur.Email);
+            Assert.True(valeur.IsAdmin);
+        }
+    }
+    [Fact]
+    public void UpdateUserSucessWithSameUsername()
+    {
+        _userService.Setup(x => x.IsUsernameTaken("Leuser")).Returns(true);
+        _userService.Setup(x => x.IsEmailTaken("heudfk@hdye.com")).Returns(false);
+        _userService.Setup(x => x.GetUserById(1)).Returns(new UserDto(1, "Leuser", "motdepasse", "deuxadresse@gmail.com", true));
+        _userService.Setup(x => x.UpdateUser(1, new UserDto(1, "Test1234", "Passssss", "heudfk@hdye.com", true)))
+            .Returns(new UserDto("Leuser", "Passssss", "heudfk@hdye.com", true));
+
+        var usersController = new UsersController(new NullLogger<UsersController>(), _userService.Object);
+
+        var userResult = usersController.UpdateUser(1, new UserDto(1,"Leuser", "Passssss", "heudfk@hdye.com", true));
+        if (userResult is OkObjectResult okObjectResult)
+        {
+            UserDto valeur = okObjectResult.Value as UserDto;
+
+            Assert.NotNull(valeur);
+            Assert.Equal("Leuser", valeur.Username);
+            Assert.Equal("Passssss", valeur.Password);
+            Assert.Equal("heudfk@hdye.com", valeur.Email);
+            Assert.True(valeur.IsAdmin);
+        }
+    }
+
+
+    [Fact]
+    public void PromoteUserSuccess()
+    {
+        _userService.Setup(x => x.PromoteUser(1))
+            .Returns(new UserDto(
+                1,
+                "Leuser",
+                "motdepasse",
+                "deuxadresse@gmail.com",
+                true
+            ));
+        var usersController = new UsersController(new NullLogger<UsersController>(), _userService.Object);
+
+        var userResult = usersController.PromoteUser(1);
+        if (userResult is OkObjectResult okObjectResult)
+        {
+            UserDto valeur = okObjectResult.Value as UserDto;
+
+            Assert.NotNull(valeur);
+            Assert.Equal("Leuser", valeur.Username);
+            Assert.Equal("motdepasse", valeur.Password);
+            Assert.Equal("deuxadresse@gmail.com", valeur.Email);
+            Assert.True(valeur.IsAdmin);
+        }
+    }
+
+    [Fact]
+    public void PromoteUserFail()
+    {
+        _userService.Setup(x => x.PromoteUser(1))
+            .Returns(new UserDto(
+                1,
+                "Leuser",
+                "motdepasse",
+                "deuxadresse@gmail.com",
+                true
+            ));
+        var usersController = new UsersController(new NullLogger<UsersController>(), _userService.Object);
+
+        var userResult = usersController.PromoteUser(356262);
+
+        if (userResult is BadRequestResult bdObjectResult)
+        {
+            Assert.Equal(404, bdObjectResult.StatusCode);
+        }
+    }
 
     private List<UserDto> GetUsersData()
     {

API_SQLuedo/TestEF/Service/TestBlackListDataService.cs

@@ -84,4 +84,49 @@ public class TestBlackListDataService
         Assert.True(banResult);
         Assert.True(_blackListDataService.UnbanUser("example91@email.com"));
     }
+
+    [Fact]
+    public void UnbanUser_Fail_Cause_Email_Null()
+    {
+        _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.False(_blackListDataService.UnbanUser(null));
+    }
+
+    [Fact]
+    public void GetNumberOfBanned_Success()
+    {
+        _dbContext.BlackLists.Add(new BlackListEntity { Email = "email@email.com", ExpirationDate = new DateOnly(2024,03,30)});
+        _dbContext.BlackLists.Add(new BlackListEntity { Email = "eemail@email.com", ExpirationDate = new DateOnly(2024, 03, 30) });
+        _dbContext.BlackLists.Add(new BlackListEntity { Email = "eeemail@email.com", ExpirationDate = new DateOnly(2024, 03, 30) });
+        _dbContext.SaveChanges();
+        var banResult = _blackListDataService.GetNumberOfBannedUsers();
+        Assert.Equal(3,banResult);
+    }
+
+    [Fact]
+    public void GetBannedUser_Success_Positive_Value()
+    {
+        _dbContext.BlackLists.Add(new BlackListEntity { Email = "email@email.com", ExpirationDate = new DateOnly(2024, 03, 30) });
+        _dbContext.BlackLists.Add(new BlackListEntity { Email = "eemail@email.com", ExpirationDate = new DateOnly(2024, 03, 30) });
+        _dbContext.BlackLists.Add(new BlackListEntity { Email = "eeemail@email.com", ExpirationDate = new DateOnly(2024, 03, 30) });
+        _dbContext.SaveChanges();
+        var banResult = _blackListDataService.GetBannedUsers(1,3,0);
+        Assert.Equal(3, banResult.Count());
+    }
+
+    [Fact]
+    public void GetBannedUser_Success_Negative_Value()
+    {
+        _dbContext.BlackLists.Add(new BlackListEntity { Email = "email@email.com", ExpirationDate = new DateOnly(2024, 03, 30) });
+        _dbContext.BlackLists.Add(new BlackListEntity { Email = "eemail@email.com", ExpirationDate = new DateOnly(2024, 03, 30) });
+        _dbContext.BlackLists.Add(new BlackListEntity { Email = "eeemail@email.com", ExpirationDate = new DateOnly(2024, 03, 30) });
+        _dbContext.SaveChanges();
+        var banResult = _blackListDataService.GetBannedUsers(-1, -3, 0);
+        Assert.Equal(3, banResult.Count());
+    }
 }