test unitaire

Sources/APILOL/Controllers/v1/ChampionsController.cs

@@ -126,8 +126,8 @@ namespace APILOL.Controllers.v1
                 {
                     if(champion2.Count() == 0)
                     {
-                        await dataManager.UpdateItem(champion.First(), championDTO.ToModel());
+                        var newchampion = await dataManager.UpdateItem(champion.First(), championDTO.ToModel());
-                        return Ok();
+                        return Ok(newchampion);
 
                     }
                     _logger.LogError("champion already exist with this unique name.");

Sources/APILOL/Program.cs

@@ -1,6 +1,7 @@
 using Microsoft.AspNetCore.Mvc;
 using Microsoft.AspNetCore.Mvc.ApiExplorer;
 using Microsoft.AspNetCore.Mvc.Versioning;
+using Microsoft.OpenApi.Models;
 using Model;
 using StubLib;
 using Swashbuckle.Swagger;
@@ -14,7 +15,11 @@ builder.Services.AddSingleton<IDataManager, StubData>();
 // Add services to the container.
 builder.Services.AddControllers();
 builder.Services.AddEndpointsApiExplorer();
-builder.Services.AddSwaggerGen();
+builder.Services.AddSwaggerGen(options =>
+{
+    options.SwaggerDoc("v1", new OpenApiInfo { Title = "My API v1", Version = "v1" });
+    options.SwaggerDoc("v2", new OpenApiInfo { Title = "My API v2", Version = "v2" });
+});
 
 builder.Services.AddApiVersioning(opt =>
 {

Sources/TestUnitaire/UnitTestChampion.cs

@@ -9,6 +9,7 @@ using Microsoft.Extensions.Logging.Abstractions;
 using Model;
 using StubLib;
 using System.Web.Http;
+using System.Web.Http.Results;
 using ChampionsController = APILOL.Controllers.v1.ChampionsController;
 
 namespace TestUnitaire
@@ -16,81 +17,115 @@ namespace TestUnitaire
     [TestClass]
     public class UnitTestChampion
     {
-        private readonly ChampionsController controller;
+        [TestClass]
-        private readonly StubData stub;
+        public class ChampionsControllerTest
-        public UnitTestChampion()
         {
-            stub = new StubData();
+            private readonly StubData stub;
-            controller = new ChampionsController(stub, new NullLogger<ChampionsController>());
+            private readonly ChampionsController championsStub;
-        }
+            public ChampionsControllerTest()
+            {
+                stub = new StubData();
+                championsStub = new ChampionsController(stub, new NullLogger<ChampionsController>());
+            }
 
-        [TestMethod]
+            [TestMethod]
-        public async Task TestGet()
+            public async Task TestGetChampions()
-        {
+            {
-            var champions = await controller.Get(new PageRequest());
+                //Arrange
 
-            //Assert
+                //Act
-            var resultObject = champions as OkObjectResult;
+                var total = await stub.ChampionsMgr.GetNbItems();
-            Assert.IsNotNull(resultObject);
+                var champion = await championsStub.Get(new PageRequest() { Offset = 0, Limit = 2 });
 
-            var resultType = resultObject?.Value as IEnumerable<ChampionDTO>;
+                //Assert
-            Assert.IsNotNull(resultType);
+                var objectResult = champion as OkObjectResult;
+                Assert.IsNotNull(objectResult);
 
-            Assert.AreEqual(resultType.Count(), await stub.ChampionsMgr.GetNbItems());
-        }
 
 
-        [TestMethod]
+            }
-        public async Task TestPost()
-        {
 
-            //Arange
+            [TestMethod]
-            var champion = new ChampionDTO
+            public async Task TestPostChampion()
             {
-                Name = "Jinx",
+                //Arange
-                Bio = "Awesome , great, fantastic Q",
+                var ChampionDto = new ChampionDTO
-            };
+                {
+                    Name = "Winrrard",
+                    Bio = "The amazing champ",
+                    Class = ChampionClass.Assassin,
+                    Icon = "",
+                    Image = new LargeImage(""),
+                    Skills = new List<SkillDTO>()
+                {
+                    new SkillDTO() {Name = "skill", Description="Empty", Type = SkillType.Unknown}
+                },
+                };
 
-            //Act
+                //Act
-            var championsResult = await controller.Post(champion);
+                var championsResult = await championsStub.Post(ChampionDto);
 
-            //Assert
+                //Assert
-            var objectResult = championsResult as CreatedAtActionResult;
+                var objectResult = championsResult as CreatedAtActionResult;
-            Assert.IsNotNull(objectResult);
+                Assert.IsNotNull(objectResult);
 
-            var champions = objectResult?.Value as ChampionDTO;
+                var champions = objectResult?.Value as ChampionDTO;
-            Assert.IsNotNull(champions);
+                Assert.IsNotNull(champions);
-        }
 
-        [TestMethod]
+                Assert.AreEqual("Winrrard", champions.Name);
-        public async Task TestDelete()
-        {
-            //Arange
-            string championName = "Aatrox";
 
 
-            // Act
+                Assert.AreEqual("skill", champions.Skills.First().Name);
-            var result = await controller.Delete(championName);
+                Assert.AreEqual("Empty", champions.Skills.First().Description);
 
-            // Assert
+            }
-            Assert.IsInstanceOfType(result, typeof(OkObjectResult));
-            Assert.IsTrue((await stub.ChampionsMgr.GetItemsByName(championName, 0, await stub.ChampionsMgr.GetNbItems())).Count() == 0);
-        }
 
-        [TestMethod]
-        public async Task TestUpdate()
-        {
-            //Arange
-            string championName = "Aatrox";
-            var updatedChampion = new ChampionDTO {Name = "Bibouuu", Bio = "Updated Bio" };
 
+            [TestMethod]
+            public async Task TestPutChampion()
+            {
+                //Arange
+                var ChampionDto = new ChampionDTO
+                {
+                    Name = "Aatrox",
+                    Bio = "The amazing champ",
+                    Class = ChampionClass.Assassin,
+                    Icon = "",
+                    Image = new LargeImage(""),
+                    Skills = new List<SkillDTO>()
+                {
+                    new SkillDTO() {Name = "skill", Description="Empty", Type = SkillType.Unknown}
+                },
+                };
+
+                //Act
+                var championsResult = await championsStub.PutAsync(ChampionDto.Name, ChampionDto);
+
+                //Assert
+                var objectResult = championsResult as OkObjectResult;
+                Assert.IsNull(objectResult);
+
+
+            }
+
+            [TestMethod]
+            public async Task TestDeleteChampion()
+            {
+                //Arange
+
+
+                //Act
+                var total = await stub.ChampionsMgr.GetNbItems();
+                var championsResult = await championsStub.Delete("Aatrox");
+
+                //Assert
+                var objectResult = championsResult as OkObjectResult;
+                Assert.IsNotNull(objectResult);
+
+                Assert.AreNotEqual(await stub.ChampionsMgr.GetNbItems(), total);
 
-            // Act
+            }
-            var result = await controller.PutAsync(championName, updatedChampion);
 
-            // Assert
-            Assert.IsInstanceOfType(result, typeof(OkResult));
-            Assert.IsNotNull(stub.ChampionsMgr.GetItemsByName("Bibouuu",0, await stub.ChampionsMgr.GetNbItems()));
         }