✅ Test TurnEntity

Sources/Data/EF/Games/TurnEntity.cs

@@ -5,15 +5,54 @@ using Data.EF.Players;
 
 namespace Data.EF.Games
 {
-    public class TurnEntity
+    public sealed class TurnEntity: IEquatable<TurnEntity>
     {
         public Guid ID { get; set; }
         public DateTime When { get; set; }
-        public PlayerEntity Player { get; set; }
+        public PlayerEntity PlayerEntity { get; set; }
         public Guid PlayerEntityID { get; set; }
-        public ICollection<DieEntity> Dice { get; set; } // many to many
-        public List<DieTurn> DieTurns { get; set; }
-        public ICollection<FaceEntity> Faces { get; set; } // many to many
-        public List<FaceTurn> FaceTurns { get; set; }
+        public ICollection<DieEntity> Dice { get; set; } = new List<DieEntity>(); // many to many
+        public List<DieTurn> DieTurns { get; set; } = new();
+        public ICollection<FaceEntity> Faces { get; set; } = new List<FaceEntity>(); // many to many
+        public List<FaceTurn> FaceTurns { get; set; } = new();
+
+        public override bool Equals(object obj)
+        {
+            if (obj is not TurnEntity)
+            {
+                return false;
+            }
+            return Equals(obj as TurnEntity);
+        }
+
+        public bool Equals(TurnEntity other)
+        {
+            return other is not null
+                && this.ID.Equals(other.ID)
+                && this.When.Equals(other.When)
+                && this.PlayerEntity.Equals(other.PlayerEntity)
+                && this.Dice.SequenceEqual(other.Dice)
+                && this.Faces.SequenceEqual(other.Faces);
+        }
+
+        public override int GetHashCode()
+        {
+            int result = HashCode.Combine(
+                ID,
+                When,
+                PlayerEntity);
+
+            foreach (DieEntity die in Dice)
+            {
+                result += die.GetHashCode();
+            }
+
+            foreach (FaceEntity face in Faces)
+            {
+                result += face.GetHashCode();
+            }
+
+            return result;
+        }
     }
 }

Sources/Data/EF/Games/TurnExtensions.cs

@@ -67,7 +67,7 @@ namespace Data.EF.Games
 
             return Turn.CreateWithSpecifiedTime(
                 when: entity.When,
-                player: entity.Player.ToModel(),
+                player: entity.PlayerEntity.ToModel(),
                 diceNFaces: DiceNFaces
             );
         }
@@ -105,8 +105,8 @@ namespace Data.EF.Games
             return new TurnEntity()
             {
                 When = model.When,
-                Player = model.Player.ToEntity(),
-                //Dice = DiceEntities,
+                PlayerEntity = model.Player.ToEntity(),
+                Dice = DiceEntities,
                 Faces = FaceEntities
             };
         }

Sources/Data/EF/Players/PlayerEntity.cs

@@ -10,7 +10,7 @@ namespace Data.EF.Players
 
         public string Name { get; set; }
 
-        public ICollection<TurnEntity> Turns { get; set; }
+        public ICollection<TurnEntity> Turns { get; set; } = new List<TurnEntity>();
 
         public override bool Equals(object obj)
         {
@@ -23,7 +23,7 @@ namespace Data.EF.Players
 
         public bool Equals(PlayerEntity other)
         {
-            return other is not null && this.ID == other.ID && this.Name == other.Name;
+            return other is not null && this.ID.Equals(other.ID) && this.Name.Equals(other.Name);
         }
 
         public override int GetHashCode()

Sources/Tests/Data_UTs/Games/TurnEntityTest.cs

@@ -1,12 +1,398 @@
-using System;
+using Data.EF.Dice;
+using Data.EF.Dice.Faces;
+using Data.EF.Games;
+using Data.EF.Joins;
+using Data.EF.Players;
+using System;
 using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
+using Xunit;
 
 namespace Tests.Data_UTs.Games
 {
     public class TurnEntityTest
     {
+
+        private readonly DieEntity numDie;
+        private readonly FaceEntity numFace1 = new NumberFaceEntity() { ID = Guid.NewGuid(), Value = 7 };
+        private readonly FaceEntity numFace2 = new NumberFaceEntity() { ID = Guid.NewGuid(), Value = 8 };
+
+        private readonly DieEntity clrDie;
+        private readonly FaceEntity clrFace1 = new ColorFaceEntity() { ID = Guid.NewGuid(), A = 255, R = 255, G = 255, B = 255 };
+        private readonly FaceEntity clrFace2 = new ColorFaceEntity() { ID = Guid.NewGuid(), A = 255, R = 0, G = 0, B = 0 };
+
+        private readonly DieEntity imgDie;
+        private readonly FaceEntity imgFace1 = new ImageFaceEntity() { ID = Guid.NewGuid(), Value = "https://a" };
+        private readonly FaceEntity imgFace2 = new ImageFaceEntity() { ID = Guid.NewGuid(), Value = "https://b" };
+
+        private readonly DieTurn dieTurn1;
+        private readonly DieTurn dieTurn2;
+        private readonly DieTurn dieTurn3;
+        private readonly DieTurn dieTurn4;
+        private readonly DieTurn dieTurn5;
+
+        private readonly FaceTurn faceTurn1;
+        private readonly FaceTurn faceTurn2;
+        private readonly FaceTurn faceTurn3;
+        private readonly FaceTurn faceTurn4;
+        private readonly FaceTurn faceTurn5;
+
+        private readonly TurnEntity turn1;
+        private readonly TurnEntity turn2;
+        private readonly TurnEntity turn3;
+
+        public TurnEntityTest()
+        {
+            numDie = new NumberDieEntity() { ID = Guid.NewGuid(), Faces = new List<NumberFaceEntity>() { numFace1 as NumberFaceEntity, numFace2 as NumberFaceEntity } };
+            clrDie = new ColorDieEntity() { ID = Guid.NewGuid(), Faces = new List<ColorFaceEntity>() { clrFace1 as ColorFaceEntity, clrFace2 as ColorFaceEntity } };
+            imgDie = new ImageDieEntity() { ID = Guid.NewGuid(), Faces = new List<ImageFaceEntity>() { imgFace1 as ImageFaceEntity, imgFace2 as ImageFaceEntity } };
+
+            turn1 = new()
+            {
+                ID = Guid.NewGuid(),
+                When = datetime1,
+                PlayerEntity = player1,
+                PlayerEntityID = player1.ID,
+                Dice = new List<DieEntity>
+                {
+                    numDie,
+                    clrDie,
+                    imgDie
+                },
+                Faces = new List<FaceEntity>
+                {
+                    numFace1,
+                    clrFace2,
+                    imgFace2
+                },
+
+            };
+
+            dieTurn1 = new() { DieEntityID = numDie.ID, DieEntity = numDie, TurnEntityID = turn1.ID, TurnEntity = turn1 };
+            dieTurn2 = new() { DieEntityID = clrDie.ID, DieEntity = clrDie, TurnEntityID = turn1.ID, TurnEntity = turn1 };
+            dieTurn3 = new() { DieEntityID = imgDie.ID, DieEntity = imgDie, TurnEntityID = turn1.ID, TurnEntity = turn1 };
+            turn1.DieTurns = new() { dieTurn1, dieTurn2, dieTurn3 };
+            numDie.DieTurns = new() { dieTurn1 };
+            clrDie.DieTurns = new() { dieTurn2 };
+            imgDie.DieTurns = new() { dieTurn3 };
+
+            faceTurn1 = new() { FaceEntityID = numFace1.ID, FaceEntity = numFace1, TurnEntityID = turn1.ID, TurnEntity = turn1 };
+            faceTurn2 = new() { FaceEntityID = clrFace2.ID, FaceEntity = clrFace2, TurnEntityID = turn1.ID, TurnEntity = turn1 };
+            faceTurn3 = new() { FaceEntityID = imgFace2.ID, FaceEntity = imgFace2, TurnEntityID = turn1.ID, TurnEntity = turn1 };
+            turn1.FaceTurns = new() { faceTurn1, faceTurn2, faceTurn3 };
+            numFace1.FaceTurns = new() { faceTurn1 };
+            clrFace2.FaceTurns = new() { faceTurn2 };
+            imgFace2.FaceTurns = new() { faceTurn3 };
+
+            Guid turn2ID = Guid.NewGuid();
+
+            turn2 = new()
+            {
+                ID = turn2ID,
+                When = datetime2,
+                PlayerEntity = player2,
+                PlayerEntityID = player2.ID,
+                Dice = new List<DieEntity>
+                {
+                    numDie,
+                    clrDie
+                },
+                Faces = new List<FaceEntity>
+                {
+                    numFace2,
+                    clrFace2
+                },
+
+            };
+
+            dieTurn4 = new() { DieEntityID = numDie.ID, DieEntity = numDie, TurnEntityID = turn2.ID, TurnEntity = turn2 };
+            dieTurn5 = new() { DieEntityID = clrDie.ID, DieEntity = clrDie, TurnEntityID = turn2.ID, TurnEntity = turn2 };
+            turn2.DieTurns = new() { dieTurn4, dieTurn5 };
+            numDie.DieTurns = new() { dieTurn4 };
+            clrDie.DieTurns = new() { dieTurn5 };
+
+            faceTurn4 = new() { FaceEntityID = numFace2.ID, FaceEntity = numFace2, TurnEntityID = turn2.ID, TurnEntity = turn2 };
+            faceTurn5 = new() { FaceEntityID = clrFace2.ID, FaceEntity = clrFace2, TurnEntityID = turn2.ID, TurnEntity = turn2 };
+            turn2.FaceTurns = new() { faceTurn4, faceTurn5 };
+            numFace2.FaceTurns = new() { faceTurn4 };
+            clrFace2.FaceTurns = new() { faceTurn5 };
+
+            turn3 = new()
+            {
+                ID = turn2ID,
+                When = datetime2,
+                PlayerEntity = player2,
+                PlayerEntityID = player2.ID,
+                Dice = new List<DieEntity>
+                {
+                    numDie,
+                    clrDie
+                },
+                Faces = new List<FaceEntity>
+                {
+                    numFace2,
+                    clrFace2
+                },
+
+            };
+        }
+
+
+
+        private readonly PlayerEntity player1 = new() { ID = Guid.NewGuid(), Name = "Marvin" };
+        private readonly PlayerEntity player2 = new() { ID = Guid.NewGuid(), Name = "Barbara" };
+
+        private readonly DateTime datetime1 = new(2020, 6, 15, 12, 15, 3, DateTimeKind.Utc);
+        private readonly DateTime datetime2 = new(2016, 12, 13, 14, 15, 16, DateTimeKind.Utc);
+
+        [Fact]
+        public void TestGetSetID()
+        {
+            // Arrange
+            TurnEntity turn = new();
+            Guid expected = Guid.NewGuid();
+
+            // Act
+            turn.ID = expected;
+            Guid actual = turn.ID;
+
+            // Assert
+            Assert.Equal(expected, actual);
+        }
+
+        [Fact]
+        public void TestGetSetWhen()
+        {
+            // Arrange
+            TurnEntity turn = new();
+            DateTime expected = datetime1;
+
+
+            // Act
+            turn.When = expected;
+            DateTime actual = turn.When;
+
+            // Assert
+            Assert.Equal(expected, actual);
+        }
+
+        [Fact]
+        public void TestGetSetPlayer()
+        {
+            // Arrange
+            TurnEntity turn = new();
+            PlayerEntity expected = player1;
+
+
+            // Act
+            turn.PlayerEntity = expected;
+            PlayerEntity actual = turn.PlayerEntity;
+
+            // Assert
+            Assert.Equal(expected, actual);
+        }
+
+        [Fact]
+        public void TestGetSetPlayerID()
+        {
+            // Arrange
+            TurnEntity turn = new();
+            Guid expected = player1.ID;
+
+            // Act
+            turn.PlayerEntityID = expected;
+            Guid actual = turn.PlayerEntityID;
+
+            // Assert
+            Assert.Equal(expected, actual);
+        }
+
+        [Fact]
+        public void TestGetSetDice()
+        {
+            // Arrange
+            TurnEntity turn = new();
+
+
+            ICollection<DieEntity> expected = new List<DieEntity>
+            {
+                numDie,
+                clrDie,
+                imgDie
+            };
+
+            // Act
+            turn.Dice = expected;
+            ICollection<DieEntity> actual = turn.Dice;
+
+            // Assert
+            Assert.Equal(expected, actual);
+        }
+
+        [Fact]
+        public void TestGetSetDieTurns()
+        {
+            // Arrange
+            TurnEntity turn = new();
+            List<DieTurn> expected = new() { dieTurn1, dieTurn2, dieTurn3 };
+
+
+            // Act
+            turn.DieTurns = expected;
+            List<DieTurn> actual = turn.DieTurns;
+
+            // Assert
+            Assert.Equal(expected, actual);
+        }
+
+        [Fact]
+        public void TestGetSetFaces()
+        {
+            // Arrange
+            TurnEntity turn = new();
+
+
+            ICollection<FaceEntity> expected = new List<FaceEntity>
+            {
+                numFace1,
+                clrFace1,
+                imgFace1
+            };
+
+            // Act
+            turn.Faces = expected;
+            ICollection<FaceEntity> actual = turn.Faces;
+
+            // Assert
+            Assert.Equal(expected, actual);
+        }
+
+        [Fact]
+        public void TestGetSetFaceTurns()
+        {
+            // Arrange
+            TurnEntity turn = new();
+            List<FaceTurn> expected = new() { faceTurn1, faceTurn2 };
+
+
+            // Act
+            turn.FaceTurns = expected;
+            List<FaceTurn> actual = turn.FaceTurns;
+
+            // Assert
+            Assert.Equal(expected, actual);
+        }
+
+        [Fact]
+        public void TestEqualsWhenNotTurnEntityThenFalse()
+        {
+            // Arrange
+            Point point;
+            TurnEntity entity;
+
+            // Act
+            point = new(1, 2);
+            entity = turn1;
+
+            // Assert
+            Assert.False(point.Equals(entity));
+            Assert.False(entity.Equals(point));
+        }
+
+        [Fact]
+        public void TestEqualsWhenNullThenFalse()
+        {
+            // Arrange
+            TurnEntity entity;
+
+            // Act
+            entity = turn2;
+
+            // Assert
+            Assert.False(entity.Equals(null));
+        }
+
+        [Fact]
+        public void TestGoesThruToSecondMethodIfObjIsTypeTurnEntity()
+        {
+            // Arrange
+            object t1;
+            TurnEntity t2;
+
+            // Act
+            t1 = turn1;
+            t2 = turn2;
+
+            // Assert
+            Assert.False(t1.Equals(t2));
+            Assert.False(t2.Equals(t1));
+        }
+
+        [Fact]
+        public void TestEqualsFalseIfNotSame()
+        {
+            // Arrange
+            TurnEntity t1;
+            TurnEntity t2;
+
+            // Act
+
+            t1 = turn1;
+            t2 = turn2;
+
+            // Assert
+            Assert.False(t1.Equals(t2));
+            Assert.False(t2.Equals(t1));
+        }
+
+        [Fact]
+        public void TestEqualsTrueIfSame()
+        {
+            // Arrange
+            TurnEntity t1;
+            TurnEntity t2;
+
+            // Act
+
+            t1 = turn2;
+            t2 = turn3; // turns 2 and 3 should be same as far as Equals is concerned
+
+            // Assert
+            Assert.True(t1.Equals(t2));
+            Assert.True(t2.Equals(t1));
+        }
+
+        [Fact]
+        public void TestSameHashFalseIfNotSame()
+        {
+            // Arrange
+            TurnEntity t1;
+            TurnEntity t2;
+
+            // Act
+
+            t1 = turn1;
+            t2 = turn2;
+
+            // Assert
+            Assert.False(t1.GetHashCode().Equals(t2.GetHashCode()));
+            Assert.False(t2.GetHashCode().Equals(t1.GetHashCode()));
+        }
+
+        [Fact]
+        public void TestSameHashTrueIfSame()
+        {
+            // Arrange
+            TurnEntity t1;
+            TurnEntity t2;
+
+            // Act
+
+            t1 = turn2;
+            t2 = turn3;
+
+            // Assert
+            Assert.True(t1.GetHashCode().Equals(t2.GetHashCode()));
+            Assert.True(t2.GetHashCode().Equals(t1.GetHashCode()));
+        }
     }
 }

Sources/Tests/Data_UTs/Players/PlayerEntityTest.cs

@@ -1,6 +1,5 @@
 using Data.EF.Players;
 using System;
-using Tests.Model_UTs;
 using Xunit;
 
 namespace Tests.Data_UTs.Players