✅ Get UTs done

Sources/Data/EF/DiceAppDbContext.cs

@@ -8,7 +8,7 @@ using System.Threading.Tasks;
 
 namespace Data.EF
 {
-    internal class DiceAppDbContext : DbContext
+    public class DiceAppDbContext : DbContext
     {
         public DbSet<PlayerEntity>? Players { get; set; }
 

Sources/Data/EF/DiceAppDbContextWithStub.cs

@@ -8,7 +8,7 @@ using System.Threading.Tasks;
 
 namespace Data.EF
 {
-    internal class DiceAppDbContextWithStub : DiceAppDbContext
+    public class DiceAppDbContextWithStub : DiceAppDbContext
     {
         protected override void OnModelCreating(ModelBuilder modelBuilder)
         {

Sources/Data/EF/Players/PlayerDBManager.cs

@@ -8,7 +8,7 @@ using System.Threading.Tasks;
 
 namespace Data.EF.Players
 {
-    internal sealed class PlayerDBManager : IManager<PlayerEntity>, IDisposable
+    public sealed class PlayerDBManager : IManager<PlayerEntity>, IDisposable
     {
         private readonly DiceAppDbContext db = new DiceAppDbContextWithStub();
 

Sources/Data/EF/Players/PlayerEntity.cs

@@ -1,4 +1,5 @@
 using Microsoft.EntityFrameworkCore;
+using Model.Players;
 using System;
 using System.Collections.Generic;
 using System.Linq;
@@ -8,15 +9,36 @@ using System.Threading.Tasks;
 namespace Data.EF.Players
 {
     [Index(nameof(Name), IsUnique = true)]
-    internal class PlayerEntity
+    public sealed class PlayerEntity : IEquatable<PlayerEntity>
     {
         public Guid ID { get; set; }
 
         public string? Name { get; set; }
 
+        public override bool Equals(object? obj)
+        {
+            if (obj is not Player)
+            {
+                return false;
+            }
+            return Equals(obj as Player);
+        }
+
+        public bool Equals(PlayerEntity? other)
+        {
+            return other is not null && this.ID == other!.ID && this.Name == other.Name;
+        }
+
+        public override int GetHashCode()
+        {
+            return HashCode.Combine(ID, Name);
+        }
+
         public override string? ToString()
         {
-            return $"{ID} -- {Name}";
+            return $"{ID.ToString().ToUpper()} -- {Name}";
         }
+
+
     }
 }

Sources/Data/EF/Players/PlayerExtensions.cs

@@ -2,7 +2,7 @@
 
 namespace Data.EF.Players
 {
-    internal static class PlayerExtensions
+    public static class PlayerExtensions
     {
         public static Player ToModel(this PlayerEntity entity)
         {

Sources/Data/Program.cs

@@ -16,7 +16,7 @@ namespace Data
         static void Main(string[] args)
         {
             using PlayerDBManager playerDBManager = new();
-            try { playerDBManager.Add(PlayerExtensions.ToEntity(new Player("Ernesto"))); }
+            try { playerDBManager.Add(new Player("Ernesto").ToEntity()); }
             catch (ArgumentException ex) { Debug.WriteLine($"{ex.Message}\n... Never mind"); }
             foreach (PlayerEntity entity in playerDBManager.GetAll()) { Debug.WriteLine(entity); }
         }

Sources/Model/Players/Player.cs

@@ -37,7 +37,7 @@ namespace Model.Players
 
         public bool Equals(Player other)
         {
-            return Name.ToUpper() == other.Name.ToUpper(); // equality is case insensitive
+            return other is not null && Name.ToUpper() == other.Name.ToUpper(); // equality is case insensitive
         }
 
         public override bool Equals(object obj)

Sources/Tests/Model_UTs/PlayerEntityTest.cs

@@ -0,0 +1,182 @@
+using Model.Players;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Xunit;
+using Data.EF.Players;
+
+namespace Tests.Model_UTs
+{
+    public class PlayerEntityTest
+    {
+        [Fact]
+        public void TestGetSetName()
+        {
+            // Arrange
+            PlayerEntity player = new();
+            string expected = "Alice";
+
+            // Act
+            player.Name = expected;
+            string actual = player.Name;
+
+            // Assert
+            Assert.Equal(expected, actual);
+        }
+
+        [Fact]
+        public void TestGetSetID()
+        {
+            // Arrange
+            PlayerEntity player = new();
+            Guid expected = new("c8f60957-dd36-4e47-a7ce-1281f4f8bea4");
+
+            // Act
+            player.ID = expected;
+            Guid actual = player.ID;
+
+            // Assert
+            Assert.Equal(expected, actual);
+        }
+
+        [Fact]
+        public void TestToString()
+        {
+            // Arrange
+            PlayerEntity player = new();
+            string IDString = "c8f60957-dd36-4e47-a7ce-1281f4f8bea4";
+            string nameString = "Bob";
+            player.ID = new Guid(IDString);
+            player.Name = nameString;
+
+            // Act
+            string expected = $"{IDString.ToUpper()} -- {nameString}";
+
+            // Assert
+            Assert.Equal(expected, player.ToString());
+        }
+
+        [Fact]
+        public void TestEqualsWhenNotPlayerEntityThenFalse()
+        {
+            // Arrange
+            Point point;
+            PlayerEntity entity;
+
+            // Act
+            point = new(1, 2);
+            entity = new() { Name = "Clyde" };
+
+            // Assert
+            Assert.False(point.Equals(entity));
+            Assert.False(entity.Equals(point));
+        }
+
+        [Fact]
+        public void TestEqualsWhenNullThenFalse()
+        {
+            // Arrange
+            PlayerEntity entity;
+
+            // Act
+            entity = new() { Name = "Clyde" };
+
+            // Assert
+            Assert.False(entity.Equals(null));
+        }
+
+        [Fact]
+        public void TestGoesThruToSecondMethodIfObjIsTypePlayerEntity()
+        {
+            // Arrange
+            Object p1;
+            PlayerEntity p2;
+
+            // Act
+            p1 = new PlayerEntity() { Name = "Marvin" };
+            p2 = new() { Name = "Clyde" };
+
+            // Assert
+            Assert.False(p1.Equals(p2));
+            Assert.False(p2.Equals(p1));
+        }
+
+        [Fact]
+        public void TestEqualsFalseIfNotSameNameOrID()
+        {
+            // Arrange
+            PlayerEntity p1;
+            PlayerEntity p2;
+            PlayerEntity p3;
+
+            // Act
+            p1 = new() { ID = new Guid("ae04ef10-bd25-4f4e-b4c1-4860fe3daaa0"), Name = "Panama" };
+            p2 = new() { ID = new Guid("ae04ef10-bd25-4f4e-b4c1-4860fe3daaa0"), Name = "Clyde" };
+            p3 = new() { ID = new Guid("846d332f-56ca-44fc-8170-6cfd28dab88b"), Name = "Clyde" };
+
+            // Assert
+            Assert.False(p1.Equals(p2));
+            Assert.False(p1.Equals(p3));
+            Assert.False(p2.Equals(p1));
+            Assert.False(p2.Equals(p3));
+            Assert.False(p3.Equals(p1));
+            Assert.False(p3.Equals(p2));
+        }
+
+        [Fact]
+        public void TestEqualsTrueIfSameIDAndName()
+        {
+            // Arrange
+            PlayerEntity p1;
+            PlayerEntity p2;
+
+            // Act
+            p1 = new() { ID = new Guid("ae04ef10-bd25-4f4e-b4c1-4860fe3daaa0"), Name = "Marley" };
+            p2 = new() { ID = new Guid("ae04ef10-bd25-4f4e-b4c1-4860fe3daaa0"), Name = "Marley" };
+
+            // Assert
+            Assert.True(p1.Equals(p2));
+            Assert.True(p2.Equals(p1));
+        }
+
+        [Fact]
+        public void TestSameHashFalseIfNotSameNameOrID()
+        {
+            // Arrange
+            PlayerEntity p1;
+            PlayerEntity p2;
+            PlayerEntity p3;
+
+            // Act
+            p1 = new() { ID = new Guid("ae04ef10-bd25-4f4e-b4c1-4860fe3daaa0"), Name = "Panama" };
+            p2 = new() { ID = new Guid("ae04ef10-bd25-4f4e-b4c1-4860fe3daaa0"), Name = "Clyde" };
+            p3 = new() { ID = new Guid("846d332f-56ca-44fc-8170-6cfd28dab88b"), Name = "Clyde" };
+
+            // Assert
+            Assert.False(p1.GetHashCode().Equals(p2.GetHashCode()));
+            Assert.False(p1.GetHashCode().Equals(p3.GetHashCode()));
+            Assert.False(p2.GetHashCode().Equals(p1.GetHashCode()));
+            Assert.False(p2.GetHashCode().Equals(p3.GetHashCode()));
+            Assert.False(p3.GetHashCode().Equals(p1.GetHashCode()));
+            Assert.False(p3.GetHashCode().Equals(p2.GetHashCode()));
+        }
+
+        [Fact]
+        public void TestSameHashTrueIfSame()
+        {
+            // Arrange
+            PlayerEntity p1;
+            PlayerEntity p2;
+
+            // Act
+            p1 = new() { ID = new Guid("ae04ef10-bd25-4f4e-b4c1-4860fe3daaa0"), Name = "Marley" };
+            p2 = new() { ID = new Guid("ae04ef10-bd25-4f4e-b4c1-4860fe3daaa0"), Name = "Marley" };
+
+            // Assert
+            Assert.True(p1.GetHashCode().Equals(p2.GetHashCode()));
+            Assert.True(p2.GetHashCode().Equals(p1.GetHashCode()));
+        }
+    }
+}

Sources/Tests/Model_UTs/PlayerExtensionsTest.cs

@@ -0,0 +1,93 @@
+using Data.EF.Players;
+using Model.Players;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Xunit;
+
+namespace Tests.Model_UTs
+{
+    public class PlayerExtensionsTest
+    {
+        [Fact]
+        public void TestToModel()
+        {
+            // Arrange
+            string name = "Alice";
+            PlayerEntity entity = new() { Name = name };
+            Player expected = new(name);
+
+            // Act
+            Player actual = entity.ToModel();
+
+            // Assert
+            Assert.Equal(expected, actual);
+        }
+
+        [Fact]
+        public void TestToEntity()
+        {
+            // Arrange
+            string name = "Bob";
+            Player model = new(name);
+            PlayerEntity expected = new() { Name = name };
+
+            // Act
+            PlayerEntity actual = model.ToEntity();
+
+            // Assert
+            Assert.Equal(expected, actual);
+        }
+
+        [Fact]
+        public void TestToModels()
+        {
+            // Arrange
+            string n1 = "Alice", n2 = "Bob", n3 = "Clyde";
+            PlayerEntity[] entities = new PlayerEntity[] {
+                new() {Name = n1 },
+                new() {Name = n2 },
+                new() {Name = n3 },
+                };
+
+            IEnumerable<Player> expected = new Player[] {
+                new(n1),
+                new(n2),
+                new(n3)
+                }.AsEnumerable();
+
+            // Act
+            IEnumerable<Player> actual = entities.ToModels();
+
+            // Assert
+            Assert.Equal(expected, actual);
+        }
+
+        [Fact]
+        public void TestToEntities()
+        {
+            // Arrange
+            string n1 = "Alice", n2 = "Bob", n3 = "Clyde";
+            Player[] models = new Player[] {
+                new(n1),
+                new(n2),
+                new(n3)
+            };
+
+            IEnumerable<PlayerEntity> expected = new PlayerEntity[] {
+                new() {Name = n1 },
+                new() {Name = n2 },
+                new() {Name = n3 },
+                }.AsEnumerable();
+
+            // Act
+            IEnumerable<PlayerEntity> actual = models.ToEntities();
+
+            // Assert
+            Assert.Equal(expected, actual);
+        }
+
+    }
+}

Sources/Tests/Model_UTs/PlayerTest.cs

@@ -128,6 +128,19 @@ namespace Tests.Model_UTs
             Assert.False(p2.Equals(p1));
         }
 
+        [Fact]
+        public void TestEqualsFalseIfNull()
+        {
+            // Arrange
+            Player player;
+
+            // Act
+            player = new("Panama");
+
+            // Assert
+            Assert.False(player.Equals(null));
+        }
+
         [Theory]
         [InlineData("devoN")]
         [InlineData(" devon")]