Add TestJoueurController.cs

Sources/BowlingApi/Controllers/JoueurController.cs

@@ -42,7 +42,7 @@ public class JoueurController:Controller
     {
         try
         {
-            if(name == null)
+            if(String.IsNullOrWhiteSpace(name))
                 return BadRequest("Le nom du joueur est obligatoire");
             
             var result = _joueurService.GetDataWithName(name).Result;

Sources/BowlingApi/Controllers/WeatherForecastController.cs

@@ -1,32 +0,0 @@
-using Microsoft.AspNetCore.Mvc;
-
-namespace BowlingApi.Controllers;
-
-[ApiController]
-[Route("[controller]")]
-public class WeatherForecastController : ControllerBase
-{
-    private static readonly string[] Summaries = new[]
-    {
-        "Freezing", "Bracing", "Chilly", "Cool", "Mild", "Warm", "Balmy", "Hot", "Sweltering", "Scorching"
-    };
-
-    private readonly ILogger<WeatherForecastController> _logger;
-
-    public WeatherForecastController(ILogger<WeatherForecastController> logger)
-    {
-        _logger = logger;
-    }
-
-    [HttpGet(Name = "GetWeatherForecast")]
-    public IEnumerable<WeatherForecast> Get()
-    {
-        return Enumerable.Range(1, 5).Select(index => new WeatherForecast
-            {
-                Date = DateOnly.FromDateTime(DateTime.Now.AddDays(index)),
-                TemperatureC = Random.Shared.Next(-20, 55),
-                Summary = Summaries[Random.Shared.Next(Summaries.Length)]
-            })
-            .ToArray();
-    }
-}

Sources/BowlingApi/WeatherForecast.cs

@@ -1,12 +0,0 @@
-namespace BowlingApi;
-
-public class WeatherForecast
-{
-    public DateOnly Date { get; set; }
-
-    public int TemperatureC { get; set; }
-
-    public int TemperatureF => 32 + (int)(TemperatureC / 0.5556);
-
-    public string? Summary { get; set; }
-}

Sources/GraphQL Project/GraphQL Project.csproj

@@ -8,6 +8,7 @@
     </PropertyGroup>
 
     <ItemGroup>
+      <PackageReference Include="FluentAssertions" Version="6.9.0" />
       <PackageReference Include="HotChocolate.AspNetCore" Version="12.16.0" />
     </ItemGroup>
 

Sources/Tests/BowlingAPITest/BowlingAPITest.csproj

@@ -27,4 +27,10 @@
       <ProjectReference Include="..\..\BowlingService\BowlingService.csproj" />
     </ItemGroup>
 
+    <ItemGroup>
+      <Reference Include="FluentAssertions">
+        <HintPath>..\..\..\..\..\.nuget\packages\fluentassertions\6.9.0\lib\net6.0\FluentAssertions.dll</HintPath>
+      </Reference>
+    </ItemGroup>
+
 </Project>

Sources/Tests/BowlingAPITest/TestJoueurController.cs

@@ -1,4 +1,5 @@
 using DTOs;
+using FluentAssertions;
 
 namespace BowlingAPITest;
 
@@ -8,15 +9,22 @@ public  class TestController
     public  async void Get_ShouldReturnOkResult()
     {
         // Arrange
+        var joueur1 = new JoueurDTO { Pseudo = "John Doe" };
+        var joueur2 = new JoueurDTO { Pseudo = "Jane Smith" };
+        var joueurs = GetTestItems();
         var mockService = new Mock<IJoueurService>();
-        mockService.Setup(service => service.GetAll()).ReturnsAsync(new List<JoueurDTO>());
+        mockService.Setup(service => service.GetAll()).ReturnsAsync(joueurs);
         var controller = new JoueurController(mockService.Object);
         
         // Act
-        var result = await controller.Get();
+        var result= await controller.Get() as OkObjectResult;
+        var value = result.Value as List<JoueurDTO>;
         
         // Assert
-        Assert.IsType<OkObjectResult>(result);
+        result.Should().NotBeNull();
+        value.Should().NotBeNull();
+        result.StatusCode.Should().Be(200);
+        value.Should().BeEquivalentTo(joueurs);
         
     }
     
@@ -47,18 +55,160 @@ public  class TestController
         return testItems;
     }
     
-    // [Fact]
-    // public  async void GetById_ShouldReturnNotFound()
-    // {
-    //     // Arrange
-    //     var mockService = new Mock<IJoueurService>();
-    //     mockService.Setup(service => service.Get(1)).ReturnsAsync((JoueurDTO)null);
-    //     var controller = new JoueurController(mockService.Object);
-    //     
-    //     // Act
-    //     var result = await controller.Get(1);
-    //     
-    //     // Assert
-    //     Assert.IsType<NotFoundResult>(result);
-    // }
+    [Fact]
+    public async Task Get_With_Invalid_Name_Should_Return_BadRequest()
+    {
+        // Arrange
+        var joueurController = new JoueurController(null);
+
+        // Act
+        var result = await joueurController.Get(null);
+
+        // Assert
+        result.Should().BeOfType<BadRequestObjectResult>();
+        var badRequestResult = result as BadRequestObjectResult;
+        badRequestResult.Value.Should().Be("Le nom du joueur est obligatoire");
+    }
+    
+    [Fact]
+    public async Task Get_With_Valid_Name_Should_Return_Ok_With_Joueur()
+    {
+        // Arrange
+        var joueur = new JoueurDTO { Id = 1, Pseudo = "John Doe" };
+        var joueurServiceMock = new Mock<IJoueurService>();
+        joueurServiceMock.Setup(x => x.GetDataWithName("John Doe")).ReturnsAsync(joueur);
+        var joueurController = new JoueurController(joueurServiceMock.Object);
+
+        // Act
+        var result = await joueurController.Get("John Doe");
+
+        // Assert
+        result.Should().BeOfType<OkObjectResult>();
+        var okResult = result as OkObjectResult;
+        okResult.Value.Should().BeEquivalentTo(joueur);
+    }
+    
+    [Fact]
+    public async Task Post_With_Invalid_Joueur_Should_Return_BadRequest()
+    {
+        // Arrange
+        var joueurController = new JoueurController(null);
+
+        // Act
+        var result = await joueurController.Post(null);
+
+        // Assert
+        result.Should().BeOfType<ActionResult<JoueurDTO>>();
+        var actionResult = result as ActionResult<JoueurDTO>;
+        actionResult.Result.Should().BeOfType<BadRequestObjectResult>();
+        var badRequestResult = actionResult.Result as BadRequestObjectResult;
+        badRequestResult.Value.Should().Be("Le joueur est obligatoire");
+    }
+    
+    [Fact]
+    public async Task Post_With_Valid_Joueur_Should_Return_Created_With_Joueur()
+    {
+        // Arrange
+        var joueur = new JoueurDTO { Id = 1, Pseudo = "John Doe" };
+        var joueurServiceMock = new Mock<IJoueurService>();
+        joueurServiceMock.Setup(x => x.Add(joueur)).ReturnsAsync(joueur);
+        var joueurController = new JoueurController(joueurServiceMock.Object);
+
+        // Act
+        var result = await joueurController.Post(joueur);
+
+        // Assert
+        result.Should().BeOfType<ActionResult<JoueurDTO>>();
+        var actionResult = result as ActionResult<JoueurDTO>;
+        actionResult.Result.Should().BeOfType<CreatedAtActionResult>();
+        var createdResult = actionResult.Result as CreatedAtActionResult;
+        createdResult.Value.Should().BeEquivalentTo(joueur);
+    }
+    
+    [Fact]
+    public async Task Put_With_Invalid_Joueur_Should_Return_BadRequest()
+    {
+        // Arrange
+        var joueurController = new JoueurController(null);
+
+        // Act
+        var result = await joueurController.Put(null, null);
+
+        // Assert
+        result.Should().BeOfType<ActionResult<JoueurDTO>>();
+        var actionResult = result as ActionResult<JoueurDTO>;
+        actionResult.Result.Should().BeOfType<BadRequestObjectResult>();
+        var badRequestResult = actionResult.Result as BadRequestObjectResult;
+        badRequestResult.Value.Should().Be("Le joueur est obligatoire");
+    }
+    
+    [Fact]
+    public async Task Put_With_Valid_Joueur_Should_Return_Ok_With_Joueur()
+    {
+        // Arrange
+        var joueur = new JoueurDTO { Id = 1, Pseudo = "John Doe" };
+        var joueurServiceMock = new Mock<IJoueurService>();
+        joueurServiceMock.Setup(x => x.Update(joueur)).ReturnsAsync(true);
+        var joueurController = new JoueurController(joueurServiceMock.Object);
+
+        // Act
+        var result = await joueurController.Put(joueur.Pseudo, joueur);
+
+        // Assert
+        result.Should().BeOfType<ActionResult<JoueurDTO>>();
+        var actionResult = result as ActionResult<JoueurDTO>;
+        actionResult.Result.Should().BeOfType<OkObjectResult>();
+    }
+    
+    //test Get_ShouldReturnNotFound
+    [Fact]
+    public async Task Get_ShouldReturnNotFound()
+    {
+        // Arrange
+        var mockService = new Mock<IJoueurService>();
+        mockService.Setup(service => service.GetAll()).ReturnsAsync((List<JoueurDTO>)null);
+        var controller = new JoueurController(mockService.Object);
+        
+        // Act
+        var result = await controller.Get();
+        
+        // Assert
+        result.Should().BeOfType<NotFoundResult>();
+    }
+    
+    [Fact]
+    public async Task Get_White_Name_ShouldReturnNotFound()
+    {
+        // Arrange
+        
+        var joueur2 = new JoueurDTO { Pseudo = "Jane Smith" };
+        var mockService = new Mock<IJoueurService>();
+        mockService.Setup(service => service.GetDataWithName("Jane Smith")).ReturnsAsync(joueur2);
+        var controller = new JoueurController(mockService.Object);
+        
+        // Act
+        var result = await controller.Get("John Doe");
+        
+        // Assert
+        result.Should().BeOfType<NotFoundResult>();
+    }
+    
+    //test Get_ShouldReturn InternalServerError
+    [Fact]
+    public async Task Get_ShouldReturnInternalServerError()
+    {
+        // Arrange
+        var mockService = new Mock<IJoueurService>();
+        mockService.Setup(service => service.GetAll()).ThrowsAsync(new Exception());
+        var controller = new JoueurController(mockService.Object);
+        
+        // Act
+        var result = await controller.Get() as ObjectResult;
+        
+        // Assert
+        result.Should().BeOfType<ObjectResult>();
+        result.StatusCode.Should().Be(500);
+    }
+    
+    
 }