Adding tests on runepages

EntityFramework_LoL/Sources/Business/DbData.Champions.cs

@@ -83,7 +83,7 @@ namespace Business
             public async Task<IEnumerable<Champion?>> GetItemsByRunePage(RunePage? runePage, int index, int count, string? orderingPropertyName = null, bool descending = false)
             {
 
-                return parent.DbContext.champions.GetItemsWithFilterAndOrdering(
+                return parent.DbContext.champions.Include("runepages").GetItemsWithFilterAndOrdering(
                         c => c.runepages.Any(rp => rp.Equals(runePage.ToEntity(parent.DbContext))),
                         index, count,
                         orderingPropertyName, descending).Select(c => c.ToModel());

EntityFramework_LoL/Sources/Business/DbData.RunePages.cs

@@ -1,4 +1,5 @@
-using EntityMapper;
+using Entities;
+using EntityMapper;
 using Microsoft.EntityFrameworkCore;
 using Model;
 
@@ -27,8 +28,22 @@ namespace Business
 
             public async Task<bool> DeleteItem(RunePage? item)
             {
-                parent.DbContext.runepages.Remove(item.ToEntity(parent.DbContext));
-                return true;
+
+                try
+                {
+                    var toDelete = parent.DbContext.runepages.Find(item.Name);
+                    if (toDelete != null)
+                    {
+                        parent.DbContext.runepages.Remove(toDelete);
+                        parent.DbContext.SaveChanges();
+                        return true;
+                    }
+                    return false;
+                }
+                catch (DbUpdateException)
+                {
+                    return false;
+                }
             }
 
             public async Task<IEnumerable<RunePage?>> GetItems(int index, int count, string? orderingPropertyName = null, bool descending = false)
@@ -41,7 +56,7 @@ namespace Business
 
             public async Task<IEnumerable<RunePage?>> GetItemsByChampion(Champion? champion, int index, int count, string? orderingPropertyName = null, bool descending = false)
             {
-                return parent.DbContext.runepages.GetItemsWithFilterAndOrdering(
+                return parent.DbContext.runepages.Include("champions").GetItemsWithFilterAndOrdering(
                     rp => rp.champions.Any(c => c.Name.Equals(champion.Name)),
                     index, count,
                     orderingPropertyName, descending).Select(rp => rp.ToModel(parent.DbContext));
@@ -87,9 +102,22 @@ namespace Business
 
             public async Task<RunePage?> UpdateItem(RunePage? oldItem, RunePage? newItem)
             {
-                parent.DbContext.runepages.Remove(oldItem.ToEntity(parent.DbContext));
-                parent.DbContext.runepages.Add(newItem.ToEntity(parent.DbContext));
+                var toUpdate = parent.DbContext.runepages.Include("entries")
+                    .Where(x => x.Name.Equals(newItem.Name)).First();
+                try
+                {
+                    toUpdate.entries = newItem.Runes.Select(r => new RunePageRuneEntity()
+                                                                {
+                                                                    category = r.Key,
+                                                                    rune = r.Value.ToEntity(parent.DbContext),
+                                                                }).ToList();
+
+                    parent.DbContext.SaveChanges();
+
+                }
+                catch (DbUpdateException) { }
                 return newItem;
+
             }
         }
     }

EntityFramework_LoL/Sources/TestEF/TestRunePage.cs

@@ -6,6 +6,7 @@ using Model;
 using Shared;
 using System;
 using System.Collections.Generic;
+using System.Data;
 using System.Linq;
 using System.Text;
 using System.Threading.Tasks;
@@ -29,6 +30,7 @@ namespace TestEF
             {
                 var manager = new DbData(context).RunePagesMgr;
                 var runeManager = new DbData(context).RunesMgr;
+                var championManager = new DbData(context).ChampionsMgr;
 
                 context.Database.EnsureCreated();
 
@@ -64,18 +66,45 @@ namespace TestEF
                 await manager.AddItem(runepage1);
                 await manager.AddItem(runepage2);
                 await manager.AddItem(runepage3);
+
+                Champion batman = new("Batman", ChampionClass.Assassin, "icon_1", "image_1", "L'ombre de la nuit");
+                Champion endeavor = new("Endeavor", ChampionClass.Tank, "icon_2", "image_2", "Feu brûlant énernel");
+                Champion escanor = new("Escanor", ChampionClass.Fighter, "icon_3", "image_3", "1, 2, 3, Soleil");
+
+                await championManager.AddItem(batman);
+                await championManager.AddItem(endeavor);
+                await championManager.AddItem(escanor);
+
+
+                var runepage_entities = context.runepages;
+                var champion_entities = context.champions;
+
+                var damages = runepage_entities.Find("Damages");
+                var hawk = runepage_entities.Find("Hawk");
+                var juggler = runepage_entities.Find("Juggler");
+
+                champion_entities.Find("Batman")!.runepages = new List<RunePageEntity>() { hawk, juggler };
+                champion_entities.Find("Endeavor")!.runepages = new List<RunePageEntity>() { damages };
+                champion_entities.Find("Escanor")!.runepages = new List<RunePageEntity>() { damages };
+                context.SaveChanges();
+
             }
 
             //uses another instance of the context to do the tests
             using (var context = new LolDbContext(options))
             {
                 var manager = new DbData(context).RunePagesMgr;
+                var championManager = new DbData(context).ChampionsMgr;
 
                 context.Database.EnsureCreated();
 
                 Model.Rune rune5 = new("Radiance", RuneFamily.Domination);
                 Model.Rune rune1 = new("Sanglante", RuneFamily.Domination);
 
+                Champion batman = new("Batman", ChampionClass.Assassin, "icon_1", "image_1", "L'ombre de la nuit");
+                Champion endeavor = new("Endeavor", ChampionClass.Tank, "icon_2", "image_2", "Feu brûlant énernel");
+
+
                 var nbItems = await manager.GetNbItems();
                 Assert.Equal(3, nbItems);
 
@@ -88,8 +117,168 @@ namespace TestEF
 
                 items = await manager.GetItemsByRune(rune1, 0, nbItems);
                 Assert.Equal("Damages", items.First().Name);
+
+                Assert.Equal(2, await manager.GetNbItemsByChampion(batman));
+                Assert.Equal("Damages", (await manager.GetItemsByChampion(endeavor, 0, 3)).First()!.Name);
+
+                Assert.Equal(2, await championManager.GetNbItemsByRunePage(new("Damages")));
+                Assert.Equal("Batman", (await championManager.GetItemsByRunePage(new("Juggler"), 0, 3)).First()!.Name);
+
             }
         }
 
+        [Fact]
+        public async void Test_Update()
+        {
+            //connection must be opened to use In-memory database
+            var connection = new SqliteConnection("DataSource=:memory:");
+            connection.Open();
+
+            var options = new DbContextOptionsBuilder<LolDbContext>()
+                .UseSqlite(connection)
+                .Options;
+
+            using (var context = new LolDbContext(options))
+            {
+                var manager = new DbData(context).RunePagesMgr;
+                var runeManager = new DbData(context).RunesMgr;
+
+                context.Database.EnsureCreated();
+
+                Model.Rune rune1 = new("Sanglante", RuneFamily.Domination);
+                Model.Rune rune2 = new("Oeil de l'esprit", RuneFamily.Precision);
+                Model.Rune rune3 = new("Concrétisation", RuneFamily.Unknown);
+                Model.Rune rune4 = new("The moon", RuneFamily.Unknown);
+                Model.Rune rune5 = new("Radiance", RuneFamily.Domination);
+                Model.Rune rune6 = new("Bullseye", RuneFamily.Precision);
+
+                RunePage runepage1 = new("Damages");
+                runepage1[Category.Major] = rune1;
+                runepage1[Category.Minor1] = rune2;
+                runepage1[Category.Minor2] = rune5;
+
+                RunePage runepage2 = new("Hawk");
+                runepage2[Category.Major] = rune6;
+                runepage2[Category.Minor1] = rune2;
+
+                RunePage runepage3 = new("Juggler");
+                runepage3[Category.Major] = rune5;
+                runepage3[Category.Minor1] = rune3;
+                runepage3[Category.Minor2] = rune2;
+
+                await runeManager.AddItem(rune1);
+                await runeManager.AddItem(rune2);
+                await runeManager.AddItem(rune3);
+                await runeManager.AddItem(rune4);
+                await runeManager.AddItem(rune5);
+                await runeManager.AddItem(rune6);
+
+                await manager.AddItem(runepage1);
+                await manager.AddItem(runepage2);
+                await manager.AddItem(runepage3);
+            }
+
+            //uses another instance of the context to do the tests
+            using (var context = new LolDbContext(options))
+            {
+                var manager = new DbData(context).RunePagesMgr;
+                Model.Rune rune1 = new("Sanglante", RuneFamily.Domination);
+                Model.Rune rune6 = new("Bullseye", RuneFamily.Precision);
+
+                context.Database.EnsureCreated();
+
+                Assert.Equal(1, await manager.GetNbItemsByRune(rune1));
+                Assert.Equal(1, await manager.GetNbItemsByRune(rune6));
+
+                RunePage after = new("Hawk");
+                after[Category.Major] = rune1;
+
+                await manager.UpdateItem(new("Hawk"), after);
+
+                Assert.Equal(2, await manager.GetNbItemsByRune(rune1));
+                Assert.Equal(0, await manager.GetNbItemsByRune(rune6));
+
+                context.SaveChanges();
+            }
+        }
+
+        [Fact]
+        public async void Test_Delete()
+        {
+            //connection must be opened to use In-memory database
+            var connection = new SqliteConnection("DataSource=:memory:");
+            connection.Open();
+
+            var options = new DbContextOptionsBuilder<LolDbContext>()
+                .UseSqlite(connection)
+                .Options;
+
+            //prepares the database with one instance of the context
+            using (var context = new LolDbContext(options))
+            {
+                var manager = new DbData(context).RunePagesMgr;
+                var runeManager = new DbData(context).RunesMgr;
+
+                context.Database.EnsureCreated();
+
+                Model.Rune rune1 = new("Sanglante", RuneFamily.Domination);
+                Model.Rune rune2 = new("Oeil de l'esprit", RuneFamily.Precision);
+                Model.Rune rune3 = new("Concrétisation", RuneFamily.Unknown);
+                Model.Rune rune4 = new("The moon", RuneFamily.Unknown);
+                Model.Rune rune5 = new("Radiance", RuneFamily.Domination);
+                Model.Rune rune6 = new("Bullseye", RuneFamily.Precision);
+
+                RunePage runepage1 = new("Damages");
+                runepage1[Category.Major] = rune1;
+                runepage1[Category.Minor1] = rune2;
+                runepage1[Category.Minor2] = rune5;
+
+                RunePage runepage2 = new("Hawk");
+
+                runepage2[Category.Major] = rune6;
+                runepage2[Category.Minor1] = rune2;
+
+                RunePage runepage3 = new("Juggler");
+                runepage3[Category.Major] = rune5;
+                runepage3[Category.Minor1] = rune3;
+                runepage3[Category.Minor2] = rune2;
+
+                await runeManager.AddItem(rune1);
+                await runeManager.AddItem(rune2);
+                await runeManager.AddItem(rune3);
+                await runeManager.AddItem(rune4);
+                await runeManager.AddItem(rune5);
+                await runeManager.AddItem(rune6);
+
+                await manager.AddItem(runepage1);
+                await manager.AddItem(runepage2);
+                await manager.AddItem(runepage3);
+            }
+
+            //uses another instance of the context to do the tests
+            using (var context = new LolDbContext(options))
+            {
+                var manager = new DbData(context).RunePagesMgr;
+
+                Model.Rune rune2 = new("Oeil de l'esprit", RuneFamily.Precision);
+
+
+                context.Database.EnsureCreated();
+
+                Assert.Equal(3, await manager.GetNbItems());
+
+                await manager.DeleteItem(new("Juggler"));
+
+                Assert.Equal(2, await manager.GetNbItems());
+
+                Assert.Equal(1, await manager.GetNbItemsByName("e"));
+
+                Assert.Equal(1, await manager.GetNbItemsByRune(rune2));
+
+
+            }
+
+        }
+
     }
 }