Merge pull request 'newBranch' (#11) from newBranch into main

Reviewed-on: #11

Sources/BowlingApi/Controllers/PartieController.cs

@@ -29,9 +29,20 @@ namespace BowlingApi.Controllers
 
 
 
-
+        /// <summary>
+        /// Get all partie
+        /// GET: api/parti
+        /// </summary>
+        /// <returns>la liste des parti </returns>
+        /// <response code="200">Retourne la liste des joueurs</response>
+        /// <response code="404">Si la liste est vide</response>
+        /// <response code="500">Si une erreur est survenue</response>
         // GET: api/Partie
         [HttpGet]
+        [ProducesResponseType(typeof(string), StatusCodes.Status500InternalServerError)]
+        [ProducesResponseType(typeof(string), StatusCodes.Status404NotFound)]
+        [ProducesResponseType(typeof(string), StatusCodes.Status400BadRequest)]
+        [ProducesResponseType(typeof(JoueurDTO), StatusCodes.Status200OK)]
         public async Task<IActionResult> Get()
         {
             try
@@ -78,9 +89,18 @@ namespace BowlingApi.Controllers
             }
 
         }
-
+        /// <summary>
-        // POST: api/Partie
+        /// Creeation
+        /// POST: api/parti
+        /// </summary>
+        /// <param name="parti"></param>
+        /// <response code="201">Retourne la parti créé</response>
+        /// <response code="400">Si la parti est null</response>
+        /// <response code="500">Si une erreur est survenue</response>
         [HttpPost]
+        [ProducesResponseType(typeof(string), StatusCodes.Status500InternalServerError)]
+        [ProducesResponseType(typeof(string), StatusCodes.Status400BadRequest)]
+        [ProducesResponseType(typeof(JoueurDTO), StatusCodes.Status201Created)]
         public async Task<ActionResult<PartieDTO>> Post([FromBody] PartieDTO parti)
         {
 
@@ -103,9 +123,23 @@ namespace BowlingApi.Controllers
 
         }
 
-        // PUT: api/Partie/5
+        /// <summary>
+        /// Modification partie
+        /// PUT: api/parti/5
+        /// </summary>
+        /// <param name="id"></param>
+        /// <param name="partie"></param>
+        /// <response code="200">Retourne la modification</response>
+        /// <response code="400">Si le partie est null</response>
+        /// <response code="404">Si le partie n'existe pas</response>
+        /// <response code="500">Si une erreur est survenue</response>
         [HttpPut("{id}")]
-        public async Task<ActionResult<PartieDTO>> Put(string name, [FromBody] PartieDTO partie)
+        [ProducesResponseType(typeof(string), StatusCodes.Status500InternalServerError)]
+        [ProducesResponseType(typeof(string), StatusCodes.Status404NotFound)]
+        [ProducesResponseType(typeof(string), StatusCodes.Status400BadRequest)]
+        [ProducesResponseType(typeof(PartieDTO), StatusCodes.Status200OK)]
+        
+        public async Task<ActionResult<PartieDTO>> Put(long id, [FromBody] PartieDTO partie)
         {
             try
             {

Sources/GraphQL Project/GraphQL Project.csproj

@@ -7,6 +7,7 @@
         <RootNamespace>GraphQL_Project</RootNamespace>
     </PropertyGroup>
 
+    <PropertyGroup Condition=" '$(RunConfiguration)' == 'GraphQL' " />
     <ItemGroup>
       <PackageReference Include="FluentAssertions" Version="6.9.0" />
       <PackageReference Include="HotChocolate.AspNetCore" Version="12.16.0" />

Sources/GraphQL Project/Properties/launchSettings.json

@@ -18,8 +18,6 @@
     },
     "GraphQL": {
       "commandName": "Project",
-      "dotnetRunMessages": true,
-      "launchBrowser": false,
       "applicationUrl": "https://localhost:5002",
       "environmentVariables": {
         "ASPNETCORE_ENVIRONMENT": "Development"

Sources/Tests/BowlingAPITest/TestPartiControlleur.cs

@@ -0,0 +1,192 @@
+using DTOs;
+using FluentAssertions;
+
+namespace BowlingAPITest
+{
+    public class TestPartiControlleur
+    {
+        [Fact]
+        public async void Get_ShouldReturnOkResult()
+        {
+            // Arrange
+            var partie1 = new PartieDTO { Score = 1 };
+            var partie2 = new PartieDTO { Score = 2 };
+            var parti = GetTestItems();
+            var mockService = new Mock<IpartieService>();
+            mockService.Setup(service => service.GetAll()).ReturnsAsync(parti);
+            var controller = new PartieController(mockService.Object);
+
+            // Act
+            var result = await controller.Get() as OkObjectResult;
+            var value = result.Value as List<PartieDTO>;
+
+            // Assert
+            result.Should().NotBeNull();
+            value.Should().NotBeNull();
+            result.StatusCode.Should().Be(200);
+            value.Should().BeEquivalentTo(parti);
+
+        }
+        [Fact]
+        public async void Get_ShouldReturnAllItems()
+        {
+            // Arrange
+            var testItems = GetTestItems();
+            var mockService = new Mock<IpartieService>();
+            mockService.Setup(service => service.GetAll()).ReturnsAsync(testItems);
+            var controller = new PartieController(mockService.Object);
+
+            // Act
+            var result = await controller.Get();
+
+            // Assert
+            var okResult = result as OkObjectResult;
+            var items = Assert.IsType<List<PartieDTO>>(okResult.Value);
+            Assert.Equal(2, items.Count);
+        }
+
+        private IEnumerable<PartieDTO> GetTestItems()
+        {
+
+            var testItems = new List<PartieDTO>();
+            testItems.Add(new PartieDTO { Score = 1 });
+            testItems.Add(new PartieDTO { Score = 2 });
+            return testItems;
+        }
+        //[Fact]
+        //public async Task Get_With_Invalid_id_Should_Return_BadRequest()
+        //{
+        //    // Arrange
+        //    var PartieController = new PartieController(null);
+
+        //    // Act
+        //    var result = await PartieController.Get(0);
+
+        //    // Assert
+        //    result.Should().BeOfType<BadRequestObjectResult>();
+        //    var badRequestResult = result as BadRequestObjectResult;
+        //    badRequestResult.Value.Should().Be("Le id de la partie est obligatoire");
+        //}
+
+        [Fact]
+        public async Task Get_With_Valid_id_Should_Return_Ok_With_partie()
+        {
+            // Arrange
+            var parti = new PartieDTO { Id = 1, Score = 1 };
+            var partiservicemock = new Mock<IpartieService>();
+            partiservicemock.Setup(x => x.GetDataWithId(1)).ReturnsAsync(parti);
+            var particontrolleur = new PartieController(partiservicemock.Object);
+
+            // Act
+            var result = await particontrolleur.Get(1);
+
+            // Assert
+            result.Should().BeOfType<OkObjectResult>();
+            var okResult = result as OkObjectResult;
+            okResult.Value.Should().BeEquivalentTo(parti);
+        }
+
+        //post
+
+
+
+        [Fact]
+        public async Task Put_With_Valid_parti_Should_Return_Ok_With_parti()
+        {
+            // Arrange
+            var parti = new PartieDTO { Id = 1, Score = 1 };
+            var partiServiceMock = new Mock<IpartieService>();
+            partiServiceMock.Setup(x => x.Update(parti)).ReturnsAsync(true);
+            var partiControlleur = new PartieController(partiServiceMock.Object);
+
+            // Act
+            var result = await partiControlleur.Put(parti.Id, parti);
+
+            // Assert
+            result.Should().BeOfType<ActionResult<PartieDTO>>();
+            var actionResult = result as ActionResult<PartieDTO>;
+            actionResult.Result.Should().BeOfType<OkObjectResult>();
+        }
+
+        //test Get_ShouldReturnNotFound
+        [Fact]
+        public async Task Get_ShouldReturnNotFound()
+        {
+            // Arrange
+            var mockService = new Mock<IpartieService>();
+            mockService.Setup(service => service.GetAll()).ReturnsAsync((List<PartieDTO>)null);
+            var controller = new PartieController(mockService.Object);
+
+            // Act
+            var result = await controller.Get();
+
+            // Assert
+            result.Should().BeOfType<NotFoundResult>();
+        }
+
+        //[Fact]
+        //public async Task Get_White_id_ShouldReturnNotFound()
+        //{
+        //    // Arrange
+
+        //    var partie1 = new PartieDTO { Score = 1 };
+        //    var mockService = new Mock<IpartieService>();
+        //    mockService.Setup(service => service.GetDataWithId(2)).ReturnsAsync(partie1);
+        //    var controller = new PartieController(mockService.Object);
+
+        //    // Act
+        //    var result = await controller.Get(2);
+
+        //    // Assert
+        //    result.Should().BeOfType<NotFoundResult>();
+        //}
+        [Fact]
+        public async Task Get_ShouldReturnInternalServerError()
+        {
+            // Arrange
+            var mockService = new Mock<IpartieService>();
+            mockService.Setup(service => service.GetAll()).ThrowsAsync(new Exception());
+            var controller = new PartieController(mockService.Object);
+
+            // Act
+            var result = await controller.Get() as ObjectResult;
+
+            // Assert
+            result.Should().BeOfType<ObjectResult>();
+            result.StatusCode.Should().Be(500);
+        }
+        //TEST POST
+        //[Fact]
+        //public async Task Post_With_Invalid_parti_Should_Return_BadRequest()
+        //{
+        //    // Arrange
+        //    var PartieController = new PartieController(null);
+
+        //    // Act
+        //    var result = await PartieController.Post(null);
+
+        //    // Assert
+        //    result.Should().BeOfType<ActionResult<PartieDTO>>();
+        //    var actionResult = result as ActionResult<PartieDTO>;
+        //    actionResult.Result.Should().BeOfType<BadRequestObjectResult>();
+        //    var badRequestResult = actionResult.Result as BadRequestObjectResult;
+        //    badRequestResult.Value.Should().Be("La partie est obligatoire");
+        //}
+
+
+        [Fact]
+        void test()
+        {
+            Assert.Equal(1, 1);
+           
+        }
+       
+
+
+
+
+
+    }
+
+
+}