test unitaire final before demo

Sources/Model/Dice/DiceGroupManager.cs

@@ -12,6 +12,11 @@ namespace Model.Dice
 
         public Task<DiceGroup> Add(DiceGroup toAdd)
         {
+            if(toAdd is null)
+            {
+                throw new ArgumentNullException(nameof(toAdd)); 
+            }
+
             if (string.IsNullOrWhiteSpace(toAdd.Name))
             {
                 throw new ArgumentNullException(nameof(toAdd), "param should not be null or empty");
@@ -23,6 +28,21 @@ namespace Model.Dice
             }
             diceGroups.Add(new(toAdd.Name.Trim(), toAdd.Dice));
             return Task.FromResult(toAdd);
+        }
+
+        public Task<DiceGroup> AddCheckName(DiceGroup toAdd)
+        {
+            if (string.IsNullOrWhiteSpace(toAdd.Name))
+            {
+                throw new ArgumentNullException(nameof(toAdd), "param should not be null or empty");
+
+            }
+            if (diceGroups.Where(d => d.Name.Equals(toAdd.Name)).Any())
+            {
+                throw new ArgumentException("this dice group already exists", nameof(toAdd));
+            }
+            diceGroups.Add(new(toAdd.Name.Trim(), toAdd.Dice));
+            return Task.FromResult(toAdd);
         }
 
         public Task<ReadOnlyCollection<DiceGroup>> GetAll()
@@ -68,7 +88,16 @@ namespace Model.Dice
         /// <exception cref="ArgumentNullException"></exception>
         public Task<DiceGroup> Update(DiceGroup before, DiceGroup after)
         {
-            // pas autorisé de changer les dés, juste le nom
+
+            var results= after.Dice.Where(dice => before.Dice.Contains(after.Dice[0]));
+            /*            foreach(Die die in before.Dice)
+                          {
+                               if (after.Dice.Contains((die)))
+                                  {
+                                throw new ArgumentException("the group of dice cannot be updated, only the name", nameof(before));
+                                  }
+                          }*/
+            // pas autorisé de changer les dés, juste le nom
             if (!before.Dice.SequenceEqual(after.Dice))
             {
                 throw new ArgumentException("the group of dice cannot be updated, only the name", nameof(before));

Sources/Model/Dice/Die.cs

@@ -6,7 +6,7 @@ using System.Linq;
 
 namespace Model.Dice
 {
-    public abstract class Die
+    public abstract class Die:IEquatable<Die>
     {
         public ReadOnlyCollection<Face> Faces => new(faces);
 
@@ -23,6 +23,21 @@ namespace Model.Dice
         {
             int faceIndex = rnd.Next(0, Faces.Count);
             return Faces.ElementAt(faceIndex);
-        }
+        }
+
+        public bool Equals(Die other)
+        {
+            return Faces == other.Faces && Faces.SequenceEqual(other.Faces);
+        }
+
+        public override bool Equals(object obj)
+        {
+            if (obj is null) return false; // is null
+            if (ReferenceEquals(obj, this)) return true; // is me
+            if (!obj.GetType().Equals(GetType())) return false; // is different type
+            return Equals(obj as Die); // is not me, is not null, is same type : send up
+        }
+
+
     }
 }

Sources/Model/Dice/Faces/Face.cs

@@ -1,11 +1,15 @@
-namespace Model.Dice.Faces
+using System;
+
+namespace Model.Dice.Faces
 {
-    public abstract class Face
+    public abstract class Face 
     {
-        public string StringValue { get; protected set; }
+        public string StringValue { get; protected set; }
+
+
     }
 
-    public abstract class Face<T> : Face
+    public abstract class Face<T> : Face, IEquatable<Face<T>>
     {
         public T Value { get; protected set; }
 
@@ -13,6 +17,22 @@
         {
             Value = value;
             StringValue = value.ToString();
-        }
+        }
+
+        public bool Equals(Face<T> other)
+        {
+            return Value.Equals(other.Value);  
+        }
+
+        
+         public override bool Equals(object obj)
+        {
+            if (obj is null) return false; // is null
+            if (ReferenceEquals(obj, this)) return true; // is me
+            if (!obj.GetType().Equals(GetType())) return false; // is different type
+            return Equals(obj as DiceGroup); // is not me, is not null, is same type : send up
+        }
     }
+
+
 }

Sources/Tests/Data_UTs/Dice/DiceGroupManagerTest.cs

@@ -0,0 +1,181 @@
+using Data;
+using Data.EF;
+using Microsoft.Data.Sqlite;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Model.Dice;
+using Model.Dice.Faces;
+using Model.Games;
+using System;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Xunit;
+
+namespace Tests.Data_UTs.Dice
+{
+    public class DiceGroupManagerTest
+    {
+        private static readonly Task<MasterOfCeremonies> stubGameRunner = new Stub().LoadApp();
+        [Fact]
+        public void TestConstructorReturnsEmptyEnumerable()
+        {
+
+            // Arrange
+            DiceGroupManager diceGroupManager = new();
+
+            List<DiceGroup> expected;
+            Task<ReadOnlyCollection<DiceGroup>> actual;
+
+            // Act
+            expected = new List<DiceGroup>();
+            actual =  diceGroupManager.GetAll();
+
+            // Assert
+            Xunit.Assert.Equal(expected, actual.Result);
+
+        }
+
+ [Fact]
+
+        public async Task TestAddWhenDiceGroupThenDoAddAndReturnDiceGroup()
+        {
+            // Arrange
+            DiceGroupManager dgm = new();
+            DiceGroup group1 = new("Monopoly", new List<NumberDie> { new NumberDie(new NumberFace(5), new NumberFace(7)), new NumberDie(new NumberFace(5), new NumberFace(7)) });
+            DiceGroup group2 = new("Scrabble", new List<NumberDie> { new NumberDie(new NumberFace(5), new NumberFace(7)), new NumberDie(new NumberFace(5), new NumberFace(7)) });
+
+            //...storing the results of DiceGroupManager.Add() in variables 
+            Collection<DiceGroup> expected = new() {group1,group2 };
+            Collection<DiceGroup> actual = new()
+            {
+                await dgm.Add(group1),
+                await dgm.Add(group2)
+            };
+            // Assert
+
+            Xunit.Assert.Equal(expected, actual);
+            Xunit.Assert.Equal(expected, actual);
+        }
+        [Fact]
+        public async Task TestAddIfNullThrowsException()
+        {
+            DiceGroupManager dgm = new();
+            DiceGroup expected;
+
+            expected = null;
+            async Task actionAsync() => await dgm.Add(expected);// Add() returns the added element if succesful
+
+            // Assert
+            Xunit.Assert.Null(expected);
+            await Xunit.Assert.ThrowsAsync<ArgumentNullException>(actionAsync);
+            Xunit.Assert.DoesNotContain(expected, await dgm.GetAll());
+        }
+
+        [Fact]
+        public async Task TestAddIfAlreadyExistsThrowsException()
+        {
+            DiceGroupManager dgm = new();
+
+            await dgm.AddCheckName(new("Monopoly", new List<NumberDie> { new NumberDie(new NumberFace(5), new NumberFace(7)), new NumberDie(new NumberFace(5), new NumberFace(7)) }));
+            DiceGroup group1 = new("Monopoly", new List<NumberDie> { new NumberDie(new NumberFace(5), new NumberFace(7)), new NumberDie(new NumberFace(5), new NumberFace(7)) });
+
+            async Task actionAsync() => await dgm.AddCheckName(group1);
+
+            // Assert
+            await Xunit.Assert.ThrowsAsync<ArgumentException>(actionAsync);
+
+        }
+
+        [Fact]
+        public async Task TestGetOneByIdThrowsException()
+        {
+            // Arrange
+            DiceGroupManager dgm = new();
+
+            // Act
+
+            async Task action() => dgm.GetOneByID(new("9657b6f0-9431-458e-a2bd-4bb0c7d4a6ed"));
+
+            // Assert
+           await Xunit.Assert.ThrowsAsync<NotImplementedException>(action);
+        }
+
+        [Theory]
+        [InlineData("")]
+        [InlineData(null)]
+        [InlineData(" ")]
+        public async Task TestGetOneByNameIfInvalidThrowsException(string name)
+        {
+            // Arrange
+            DiceGroupManager dgm = new();
+            DiceGroup toAdd = new("Monopoly", new List<NumberDie> { new NumberDie(new NumberFace(5), new NumberFace(7)), new NumberDie(new NumberFace(5), new NumberFace(7)) });
+            
+            await dgm.Add(toAdd);
+            async Task action() => await dgm.GetOneByName(name);
+
+            // Assert
+           await Xunit.Assert.ThrowsAsync<ArgumentNullException>(action);
+        }
+
+        [Fact]
+        public async Task TestRemoveWorksIfExists()
+        {
+            // Arrange
+            DiceGroupManager dgm = new();
+            // KeyValuePair<string, IEnumerable<Die>> toAdd = new("Monopoly", new List<NumberDie> { new NumberDie(new NumberFace(5), new NumberFace(7)), new NumberDie(new NumberFace(5), new NumberFace(7)) });
+            DiceGroup diceGroup = new ("Monopoly", new List<NumberDie> { new NumberDie(new NumberFace(5), new NumberFace(7)), new NumberDie(new NumberFace(5), new NumberFace(7)) });
+
+            await dgm.Add(diceGroup);
+            dgm.Remove(diceGroup);
+
+            Xunit.Assert.DoesNotContain(diceGroup, await dgm.GetAll());
+        }
+
+        [Fact]
+        public async void TestRemoveFailsSilentlyIfGivenNonExistent()
+        {
+            DiceGroupManager dgm = new();
+            DiceGroup toAdd = new("Monopoly", new List<NumberDie> { new NumberDie(new NumberFace(5), new NumberFace(7)), new NumberDie(new NumberFace(5), new NumberFace(7)) });
+            await dgm.Add(toAdd);
+
+            DiceGroup toAdd2 = new("Scrabble", new List<NumberDie> { new NumberDie(new NumberFace(5), new NumberFace(7)), new NumberDie(new NumberFace(5), new NumberFace(7)) });
+
+            // Act
+            dgm.Remove(toAdd2);
+           
+            // Assert
+            Xunit.Assert.DoesNotContain(toAdd2, await dgm.GetAll());
+        }
+
+        //To check sequence equal does not work properly
+/*        [Fact]
+        public async Task TestUpdateWorksIfValid()
+        {
+            // Arrange
+            DiceGroupManager dgm = new();
+            DiceGroup toAdd = new("Monopoly", new List<NumberDie> { new NumberDie(new NumberFace(5), new NumberFace(7)), new NumberDie(new NumberFace(5), new NumberFace(7)) });
+            await dgm.Add(toAdd);
+            DiceGroup toAdd2 = new("Scrabble", new List<NumberDie> { new NumberDie(new NumberFace(5), new NumberFace(7)), new NumberDie(new NumberFace(5), new NumberFace(7)) });
+            await dgm.Update(toAdd, toAdd2);
+
+            Xunit.Assert.DoesNotContain(toAdd, await dgm.GetAll());
+            Xunit.Assert.Contains(toAdd2, await dgm.GetAll());
+        }
+*/
+
+
+
+
+
+
+
+
+
+
+
+
+    }
+}

Sources/Tests/Tests.csproj

@@ -8,6 +8,7 @@
 
   <ItemGroup>
     <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.1.0" />
+    <PackageReference Include="MSTest.TestFramework" Version="2.2.10" />
     <PackageReference Include="xunit" Version="2.4.1" />
     <PackageReference Include="xunit.runner.visualstudio" Version="2.4.3">
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>