Merge pull request 'Test Get_OK' (#4) from API_testsUnitaires into API_init

Reviewed-on: #4

WF_EF_Api/StubApi/QuoteService.cs

@@ -63,6 +63,11 @@ namespace StubApi
 
         }
 
+        public Task<PaginationResult<QuoteDTO>> GetAllQuoteLang(int index, int pageSize, int lang)
+        {
+            throw new NotImplementedException();
+        }
+
         public async Task<QuoteDTO> GetDayliQuote(int lang)
         {
             throw new NotImplementedException();

WF_EF_Api/XUnitTest/APIUnitTest.cs

@@ -0,0 +1,283 @@
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.Extensions.Logging;
+using Moq;
+
+
+using WfApi.Controllers;
+using Shared;
+using DTO;
+
+namespace XUnitTest
+{
+    public class APIUnitTest
+    {
+        private readonly Mock<IUserService<UserDTO>> _mockUserService;
+        private readonly Mock<ILogger<UsersController>> _mockLogger;
+        private readonly UsersController _userController;
+
+        public APIUnitTest()
+        {
+            // Initialisation des mocks
+            _mockUserService = new Mock<IUserService<UserDTO>>();
+            _mockLogger = new Mock<ILogger<UsersController>>();
+            _userController = new UsersController(_mockUserService.Object, _mockLogger.Object);
+        }
+
+
+
+        [Fact]
+        public async Task Get_ReturnsOk_WhenUserExists()
+        {
+            // Arrange
+            var userId = 1;
+            var userDTO = new UserDTO
+            {
+                Id = userId,
+                Pseudo = "test",
+                Email = "test@unitaire.fr",
+                ImageProfil = "http://test",
+                Password = "1234"
+            };
+
+            _mockUserService.Setup(service => service.GetUserById(userId)).ReturnsAsync(userDTO); 
+
+            // Act
+            var result = await _userController.Get(userId);
+
+            // Assert
+           Assert.IsType<OkObjectResult>(result); 
+        }
+
+
+
+
+        [Fact]
+        public async Task GetAllUsers_ReturnsOk()
+        {
+            // Arrange
+            var userDTO = new UserDTO
+            {
+                Id = 1,
+                Pseudo = "test",
+                Email = "test@unitaire.fr",
+                ImageProfil = "http://test",
+                Password = "1234"
+            };
+            var userDTO2 = new UserDTO
+            {
+                Id = 2,
+                Pseudo = "test",
+                Email = "test@unitaire.fr",
+                ImageProfil = "http://test",
+                Password = "1234"
+            };
+
+            _mockUserService.Setup(service => service.GetUserById(1)).ReturnsAsync(userDTO);
+            _mockUserService.Setup(service => service.GetUserById(2)).ReturnsAsync(userDTO);
+
+            // Act
+            var result = await _userController.GetAllUsers();
+
+            // Assert
+            Assert.IsType<OkObjectResult>(result);
+        }
+
+
+
+        [Fact]
+        public async Task GetHashPassword_ReturnsOk_WhenPasswordHashIsFound()
+        {
+            // Arrange
+            var username = "testUser";
+            var expectedHash = "hashedPassword"; 
+
+            var taskResult = Task.FromResult(expectedHash);
+            _mockUserService.Setup(service => service.GetHashPassword(username)).Returns(taskResult);
+
+            // Act
+            var result = await _userController.GetHashPassword(username);
+
+            // Assert
+            Assert.IsType<OkObjectResult>(result);
+        }
+
+        [Fact]
+        public async Task GetUserByUsername_ReturnsOk_WhenPasswordHashIsFound()
+        {
+            // Arrange
+            var username = "testUser";
+            var userDTO = new UserDTO
+            {
+                Id = 1,
+                Pseudo = "testUser",
+                Email = "test@unitaire.fr",
+                ImageProfil = "http://test",
+                Password = "1234"
+            };
+
+            var taskResult = Task.FromResult(userDTO);
+            _mockUserService.Setup(service => service.GetUserByUsername(username)).Returns(taskResult);
+
+            // Act
+            var result = await _userController.GetUserByUsername(username);
+
+            // Assert
+            Assert.IsType<OkObjectResult>(result);
+        }
+
+        [Fact]
+        public async Task GetUserByEmail_ReturnsOk_WhenUserExists()
+        {
+            // Arrange
+            var email = "test@unitaire.fr";
+            var userDTO = new UserDTO
+            {
+                Id = 1,
+                Pseudo = "testUser",
+                Email = email,
+                ImageProfil = "http://test",
+                Password = "1234"
+            };
+
+            
+            var taskResult = Task.FromResult(userDTO);
+            _mockUserService.Setup(service => service.GetUserByEmail(email)).Returns(taskResult);
+
+            // Act
+            var result = await _userController.GetUserByEmail(email);
+
+            // Assert
+            Assert.IsType<OkObjectResult>(result);
+        }
+
+        [Fact]
+        public async Task GetCountUser_ReturnsOk_WhenCountIsSuccessful()
+        {
+            // Arrange
+            var expectedCount = 5;  
+            var taskResult = Task.FromResult(expectedCount);
+
+            _mockUserService.Setup(service => service.CountUser()).Returns(taskResult);
+
+            // Act
+            var result = await _userController.GetCountUser();
+
+            // Assert
+            Assert.IsType<OkObjectResult>(result);
+        }
+
+        [Fact]
+        public async Task GetExistUsername_ReturnsOk_WhenUserExists()
+        {
+            // Arrange
+            var username = "testUser";
+            var taskResult = Task.FromResult(true);
+
+            
+            _mockUserService.Setup(service => service.ExistUsername(username)).Returns(taskResult);
+
+            // Act
+            var result = await _userController.GetExistUsername(username);
+
+            // Assert
+            Assert.IsType<OkObjectResult>(result); 
+         
+        }
+
+        [Fact]
+        public async Task GetExistEmail_ReturnsOk_WhenEmailExists()
+        {
+            // Arrange
+            var email = "test@unitaire.fr";
+            var taskResult = Task.FromResult(true);  
+
+            _mockUserService.Setup(service => service.ExistEmail(email)).Returns(taskResult);
+
+            // Act
+            var result = await _userController.GetExistEmail(email);
+
+            // Assert
+            Assert.IsType<OkObjectResult>(result);
+         
+        }
+        [Fact]
+        public async Task UpdateUser_ReturnsOk_WhenUserDataIsValid()
+        {
+            // Arrange
+            var id = 1;
+            var updatedUser = new UserDTO
+            {
+                Id = id,
+                Pseudo = "UpdatedUser",
+                Email = "updated@unitaire.fr",
+                ImageProfil = "http://updatedImage.com",
+                Password = "newPassword123"
+            };
+
+            var taskResult = Task.FromResult(updatedUser);  
+
+            _mockUserService.Setup(service => service.UpdateUser(id, updatedUser)).Returns(taskResult);
+
+            // Act
+            var result = await _userController.UpdateUser(id, updatedUser);
+
+            // Assert
+            var okResult = Assert.IsType<OkObjectResult>(result);
+
+            Assert.IsType<OkObjectResult>(result);
+        }
+        [Fact]
+        public async Task CreateUser_ReturnsCreatedAtAction_WhenUserIsValid()
+        {
+            // Arrange
+            var newUser = new UserDTO
+            {
+                Id = 2,
+                Pseudo = "NewUser",
+                Email = "newuser@unitaire.fr",
+                ImageProfil = "http://newuserimage.com",
+                Password = "newPassword123"
+            };
+
+            _mockUserService.Setup(service => service.GetUserById(newUser.Id)).ReturnsAsync((UserDTO)null);
+
+            _mockUserService.Setup(service => service.AddUser(newUser)).Verifiable();
+
+            // Act
+            var result = await _userController.CreateUser(newUser);
+
+            // Assert
+            var createdResult = Assert.IsType<CreatedAtActionResult>(result);
+            Assert.Equal(newUser.Id, createdResult.RouteValues["id"]);  
+        }
+
+
+        [Fact]
+        public async Task DeletePlayer_ReturnsOk_WhenPlayerExists()
+        {
+            // Arrange
+            var id = 1;
+            var existingPlayer = new UserDTO
+            {
+                Id = id,
+                Pseudo = "ExistingUser",
+                Email = "existing@unitaire.fr",
+                ImageProfil = "http://existingimage.com",
+                Password = "existingPassword123"
+            };
+
+            _mockUserService.Setup(service => service.GetUserById(id)).ReturnsAsync(existingPlayer);
+
+            _mockUserService.Setup(service => service.RemoveUser(existingPlayer)).Verifiable();
+
+            // Act
+            var result = await _userController.DeletePlayer(id);
+
+            // Assert
+            Assert.IsType<OkObjectResult>(result);
+           
+        }
+
+
+    }
+}

WF_EF_Api/XUnitTest/UnitTest1.cs

@@ -1,11 +0,0 @@
-namespace XUnitTest
-{
-    public class UnitTest1
-    {
-        [Fact]
-        public void Test1()
-        {
-
-        }
-    }
-}

WF_EF_Api/XUnitTest/XUnitTest.csproj

@@ -11,11 +11,19 @@
 
   <ItemGroup>
     <PackageReference Include="coverlet.collector" Version="6.0.0" />
+    <PackageReference Include="Microsoft.AspNetCore.Mvc" Version="2.3.0" />
     <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.8.0" />
+    <PackageReference Include="Moq" Version="4.20.72" />
     <PackageReference Include="xunit" Version="2.5.3" />
     <PackageReference Include="xunit.runner.visualstudio" Version="2.5.3" />
   </ItemGroup>
 
+  <ItemGroup>
+    <ProjectReference Include="..\Shared\Shared.csproj" />
+    <ProjectReference Include="..\StubApi\StubApi.csproj" />
+    <ProjectReference Include="..\WfApi\WfApi.csproj" />
+  </ItemGroup>
+
   <ItemGroup>
     <Using Include="Xunit" />
   </ItemGroup>