Adding simple unit tests for SkinEntity

EntityFramework_LoL/Sources/Business/DbData.Champions.cs

@@ -1,4 +1,5 @@
 using EntityMapper;
+using Microsoft.EntityFrameworkCore;
 using Model;
 using Shared;
 using System.Diagnostics;
@@ -16,15 +17,33 @@ namespace Business
 
             public async Task<Champion?> AddItem(Champion? item)
             {
-                await parent.DbContext.champions.AddAsync(item.ToEntity());
+                try
+                {
+                    await parent.DbContext.champions.AddAsync(item.ToEntity());
+                    parent.DbContext.SaveChanges();
+                }
+                catch(OperationCanceledException){}
+                catch(DbUpdateException) {}
                 return item;
             }
 
             public async Task<bool> DeleteItem(Champion? item)
             {
-                var toDelete = parent.DbContext.champions.Where(c => c.Name==item.Name).First();
+                try
-                parent.DbContext.champions.Remove(toDelete);
+                {
-                return true;
+                    var toDelete = parent.DbContext.champions.Find(item.Name);
+                    if (toDelete!=null)
+                    {
+                        parent.DbContext.champions.Remove(toDelete);
+                        parent.DbContext.SaveChanges();
+                        return true;
+                    }
+                    return false;
+                }
+                catch (DbUpdateException)
+                {
+                    return false;
+                }
             }
 
             public async Task<IEnumerable<Champion?>> GetItems(int index, int count, string? orderingPropertyName = null, bool descending = false)
@@ -129,8 +148,13 @@ namespace Business
 
             public async Task<Champion?> UpdateItem(Champion? oldItem, Champion? newItem)
             {
-                var toUpdate = parent.DbContext.champions.Where(c => c.Name == oldItem.Name).First();
+                var toUpdate = parent.DbContext.champions.Find(oldItem.Name);
-                toUpdate = newItem.ToEntity();
+                try
+                {
+                    toUpdate = newItem.ToEntity();
+                    parent.DbContext.SaveChanges();
+
+                }catch (DbUpdateException){}
                 return newItem;
             }
         }

EntityFramework_LoL/Sources/Business/DbData.Skins.cs

@@ -1,4 +1,5 @@
 using EntityMapper;
+using Microsoft.EntityFrameworkCore;
 using Model;
 
 namespace Business
@@ -14,38 +15,50 @@ namespace Business
 
             public async Task<Skin?> AddItem(Skin? item)
             {
-                await parent.DbContext.skins.AddAsync(item.ToEntity());
+                try { 
+                    await parent.DbContext.skins.AddAsync(item.ToEntity(parent.DbContext));
+                    parent.DbContext.SaveChanges();
+                }
+                catch(OperationCanceledException){}
+                catch(DbUpdateException) {}
                 return item;
             }
 
             public async Task<bool> DeleteItem(Skin? item)
             {
-                parent.DbContext.skins.Remove(item.ToEntity());
+                try {
-                return true;
+                    var toDelete = parent.DbContext.skins.Find(item.Name);
+                    parent.DbContext.skins.Remove(toDelete);
+                    parent.DbContext.SaveChanges();
+                    return true;
+                }
+                catch(DbUpdateException) {
+                    return false;
+                }
             }
 
             public async Task<IEnumerable<Skin?>> GetItems(int index, int count, string? orderingPropertyName = null, bool descending = false)
             {
-                return parent.DbContext.skins.GetItemsWithFilterAndOrdering(
+                return parent.DbContext.skins.Include("Champion").GetItemsWithFilterAndOrdering(
                     s => true,
                     index, count,
-                    orderingPropertyName, descending).Select(s => s.ToModel());
+                    orderingPropertyName, descending).Select(s => s?.ToModel());
             }
 
             public async Task<IEnumerable<Skin?>> GetItemsByChampion(Champion? champion, int index, int count, string? orderingPropertyName = null, bool descending = false)
             {
-                return parent.DbContext.skins.GetItemsWithFilterAndOrdering(
+                return parent.DbContext.skins.Include("Champion").GetItemsWithFilterAndOrdering(
-                    s => s.Champion.Name.Equals(champion.Name),
+                    s => s.Champion.Name.Equals(champion?.Name),
                     index, count,
-                    orderingPropertyName, descending).Select(s => s.ToModel());
+                    orderingPropertyName, descending).Select(s => s?.ToModel());
             }
 
             public async Task<IEnumerable<Skin?>> GetItemsByName(string substring, int index, int count, string? orderingPropertyName = null, bool descending = false)
             {
-                return parent.DbContext.skins.GetItemsWithFilterAndOrdering(
+                return parent.DbContext.skins.Include("Champion").GetItemsWithFilterAndOrdering(
                     s => s.Name.Contains(substring),
                     index, count,
-                    orderingPropertyName, descending).Select(s => s.ToModel());
+                    orderingPropertyName, descending).Select(s => s?.ToModel());
             }
 
             public async Task<int> GetNbItems()
@@ -55,8 +68,12 @@ namespace Business
 
             public async Task<int> GetNbItemsByChampion(Champion? champion)
             {
-                return parent.DbContext.skins.Where(s => s.Champion.Name.Equals(champion.Name))
+                if (champion != null)
-                .Count();
+                {
+                    return parent.DbContext.skins.Where(s => s.Champion.Name.Equals(champion.Name))
+                    .Count();
+                }
+                return 0;
             }
 
             public async Task<int> GetNbItemsByName(string substring)
@@ -67,10 +84,16 @@ namespace Business
 
             public async Task<Skin?> UpdateItem(Skin? oldItem, Skin? newItem)
             {
-                parent.DbContext.skins.Remove(oldItem.ToEntity());
+                var toUpdate = parent.DbContext.skins.Find(oldItem.Name);
-                parent.DbContext.skins.Add(newItem.ToEntity());
+                try
+                {
+                    toUpdate.Champion = parent.DbContext.champions.Find(newItem.Champion.Name);
+
+                }
+                catch (DbUpdateException) { }
                 return newItem;
             }
         }
+
     }
 }

EntityFramework_LoL/Sources/EntityMappers/SkinMapper.cs

@@ -1,21 +1,28 @@
 using Entities;
+using Microsoft.EntityFrameworkCore;
 using Model;
 
 namespace EntityMapper
 {
     public static class SkinMapper
     {
-        public static SkinEntity ToEntity(this Skin item)
+        public static SkinEntity ToEntity(this Skin item, LolDbContext? context = null)
         {
-            throw new NotImplementedException();
+            return new()
+            {
+                Name = item.Name,
+                Champion = context?.champions.Find(item.Champion.Name) ?? item.Champion.ToEntity(),
+                ChampionForeignKey = item.Champion.Name,
+                Description = item.Description,
+                Icon = item.Icon,
+                Image = null,
+                Price = item.Price
+            };
         }
 
 
         public static Skin ToModel(this SkinEntity entity)
-        {
+        => new(entity.Name, entity.Champion.ToModel(), entity.Price, null, entity.Description);
-            throw new NotImplementedException();
-
-        }
 
     }
 }

EntityFramework_LoL/Sources/TestEF/TestChampions.cs

@@ -7,7 +7,7 @@ using Shared;
 
 namespace TestEF
 {
-    public class TestChampion
+    public class TestChampions
     {
 
         [Fact]
@@ -25,7 +25,6 @@ namespace TestEF
             {
                 var manager = new DbData(context).ChampionsMgr;
 
-                //context.Database.OpenConnection();
                 context.Database.EnsureCreated();
 
                 Champion batman = new("Batman", ChampionClass.Assassin);
@@ -35,7 +34,6 @@ namespace TestEF
                 await manager.AddItem(batman);
                 await manager.AddItem(endeavor);
                 await manager.AddItem(escanor);
-                context.SaveChanges();
             }
 
             //uses another instance of the context to do the tests
@@ -70,7 +68,6 @@ namespace TestEF
             {
                 var manager = new DbData(context).ChampionsMgr;
                 
-                //context.Database.OpenConnection();
                 context.Database.EnsureCreated();
 
                 Champion batman = new("Batman", ChampionClass.Assassin);
@@ -80,7 +77,6 @@ namespace TestEF
                 await manager.AddItem(batman);
                 await manager.AddItem(endeavor);
                 await manager.AddItem(escanor);
-                context.SaveChanges();
             }
 
             //uses another instance of the context to do the tests
@@ -95,21 +91,13 @@ namespace TestEF
                 Assert.Equal(2, itemsByName.Count());
 
                 var escanor = context.champions.Where(n => n.Name.Contains("Esc")).First();
-
                 escanor.Class = ChampionClass.Tank;
-                context.SaveChanges();
-            }
-
-            //uses another instance of the context to do the tests
-            using (var context = new LolDbContext(options))
-            {
-                var manager = new DbData(context).ChampionsMgr;
-
-                context.Database.EnsureCreated();
 
-                var itemsByName = await manager.GetItemsByClass(ChampionClass.Tank, 0, 3);
+                itemsByName = await manager.GetItemsByClass(ChampionClass.Tank, 0, 3);
 
                 Assert.Equal(2, itemsByName.Count());
+
+                context.SaveChanges();
             }
         }
 
@@ -129,7 +117,6 @@ namespace TestEF
             {
                 var manager = new DbData(context).ChampionsMgr;
 
-                //context.Database.OpenConnection();
                 context.Database.EnsureCreated();
 
                 Champion batman = new("Batman", ChampionClass.Assassin);
@@ -139,7 +126,6 @@ namespace TestEF
                 await manager.AddItem(batman);
                 await manager.AddItem(endeavor);
                 await manager.AddItem(escanor);
-                context.SaveChanges();
             }
 
             //uses another instance of the context to do the tests
@@ -153,7 +139,6 @@ namespace TestEF
 
                 var itemsByName = await manager.DeleteItem(endeavor);
                 Assert.Equal(2, await manager.GetNbItems());
-                context.SaveChanges();
             }
 
         }

EntityFramework_LoL/Sources/TestEF/TestSkins.cs

@@ -0,0 +1,186 @@
+using Business;
+using Entities;
+using Microsoft.Data.Sqlite;
+using Microsoft.EntityFrameworkCore;
+using Model;
+using Shared;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace TestEF
+{
+    public class TestSkins
+    {
+        [Fact]
+        public async void Test_Add()
+        {
+            //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).SkinsMgr;
+                var championManager = new DbData(context).ChampionsMgr;
+
+                context.Database.EnsureCreated();
+
+                Champion batman = new("Batman", ChampionClass.Assassin);
+                Champion endeavor = new("Endeavor", ChampionClass.Tank);
+                await championManager.AddItem(batman);
+                await championManager.AddItem(endeavor);
+
+                Skin batman_skin_1 = new("Batman de glace", batman);
+                Skin batman_skin_2 = new("Batman gold", batman);
+                Skin batman_skin_3 = new("L'homme araignée", batman);
+                Skin endeavor_skin_1 = new("L'abominable Endeavor", endeavor);
+
+                await manager.AddItem(batman_skin_1);
+                await manager.AddItem(batman_skin_2);
+                await manager.AddItem(batman_skin_3);
+                await manager.AddItem(endeavor_skin_1);
+            }
+
+            //uses another instance of the context to do the tests
+            using (var context = new LolDbContext(options))
+            {
+                var manager = new DbData(context).SkinsMgr;
+
+                context.Database.EnsureCreated();
+
+                var nbItems = await manager.GetNbItems();
+                Assert.Equal(4, nbItems);
+
+                var items = await manager.GetItemsByName("Batman", 0, nbItems);
+                Assert.Equal(2, items.Count());
+
+                Champion batman = new("Batman", ChampionClass.Assassin);
+                items = await manager.GetItemsByChampion(batman, 0, nbItems);
+                Assert.Equal(3, items.Count());
+            }
+
+        }
+
+        [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).SkinsMgr;
+                var championManager = new DbData(context).ChampionsMgr;
+
+                context.Database.EnsureCreated();
+
+                Champion batman = new("Batman", ChampionClass.Assassin);
+                Champion endeavor = new("Endeavor", ChampionClass.Tank);
+                await championManager.AddItem(batman);
+                await championManager.AddItem(endeavor);
+
+                Skin batman_skin_1 = new("Batman de glace", batman);
+                Skin batman_skin_2 = new("Batman gold", batman);
+                Skin batman_skin_3 = new("L'homme araignée", batman);
+                Skin endeavor_skin_1 = new("L'abominable Endeavor", endeavor);
+
+                await manager.AddItem(batman_skin_1);
+                await manager.AddItem(batman_skin_2);
+                await manager.AddItem(batman_skin_3);
+                await manager.AddItem(endeavor_skin_1);
+            }
+
+            //uses another instance of the context to do the tests
+            using (var context = new LolDbContext(options))
+            {
+                var manager = new DbData(context).SkinsMgr;
+
+                context.Database.EnsureCreated();
+
+
+                Champion batman = new("Batman", ChampionClass.Assassin);
+                Champion endeavor = new("Endeavor", ChampionClass.Tank);
+                
+                var itemsByName = await manager.GetItemsByChampion(batman, 0, 4);
+                Assert.Equal(3, itemsByName.Count());
+
+                Skin batman_skin = new("L'homme araignée", batman);
+                Skin endeavor_skin = new("L'homme araignée", endeavor);
+
+                await manager.UpdateItem(batman_skin, endeavor_skin);
+
+                itemsByName = await manager.GetItemsByChampion(batman, 0, 4);
+                Assert.Equal(2, itemsByName.Count());
+
+                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).SkinsMgr;
+                var championManager = new DbData(context).ChampionsMgr;
+
+                context.Database.EnsureCreated();
+
+                Champion batman = new("Batman", ChampionClass.Assassin);
+                Champion endeavor = new("Endeavor", ChampionClass.Tank);
+                await championManager.AddItem(batman);
+                await championManager.AddItem(endeavor);
+
+                Skin batman_skin_1 = new("Batman de glace", batman);
+                Skin batman_skin_2 = new("Batman gold", batman);
+                Skin batman_skin_3 = new("L'homme araignée", batman);
+                Skin endeavor_skin_1 = new("L'abominable Endeavor", endeavor);
+
+                await manager.AddItem(batman_skin_1);
+                await manager.AddItem(batman_skin_2);
+                await manager.AddItem(batman_skin_3);
+                await manager.AddItem(endeavor_skin_1);
+            }
+
+            //uses another instance of the context to do the tests
+            using (var context = new LolDbContext(options))
+            {
+                var manager = new DbData(context).SkinsMgr;
+
+                context.Database.EnsureCreated();
+
+                await manager.DeleteItem((await manager.GetItemsByName("L'", 0, 4)).First());
+                await manager.DeleteItem((await manager.GetItemsByName("L'", 0, 3)).First());
+
+                Assert.Equal(2, await manager.GetNbItems());
+
+                Assert.Equal(2, await manager.GetNbItemsByName("Batman"));
+
+                Champion batman = new("Batman", ChampionClass.Assassin);
+                Assert.Equal(2, await manager.GetNbItemsByChampion(batman));
+            }
+
+        }
+    }
+}