Merge pull request '✅ Fix #29 ut-playermanager' (#49) from ut-playermanager into main

Reviewed-on: #49

Sources/Model/Player.cs

@@ -15,7 +15,7 @@ namespace Model
             {
                 if (!String.IsNullOrWhiteSpace(value))
                 {
-                    name = value;
+                    name = value.Trim();
                 }
                 else throw new ArgumentException("player name may never be empty or null");
             }

Sources/Model/PlayerManager.cs

@@ -19,7 +19,7 @@ namespace Model
 
         public PlayerManager()
         {
-            players = new HashSet<Player>();
+            players = new();
         }
         /// <summary>
         /// add a new player
@@ -57,9 +57,9 @@ namespace Model
         {
             if (!String.IsNullOrWhiteSpace(name))
             {
-                Player result = players.FirstOrDefault(p => p.Name.Equals(name));
-                return new Player(result); // THIS IS A COPY (using a copy constructor)
-                // will return null by default if no such player exists
+                Player result = players.FirstOrDefault(p => p.Name.ToUpper().Equals(name.Trim().ToUpper()));
+                if (result == null) return result; // will return null by default if no such player exists
+                return new(result); // THIS IS A COPY (using a copy constructor)
             }
             return null; // we also want ot return null if no name was provided
         }

Sources/Tests/Model_UTs/PlayerManagerTest.cs

@@ -1,13 +1,203 @@
-using System;
+using Model;
+using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Text;
 using System.Threading.Tasks;
+using System.Xml.Linq;
+using Xunit;
+using Xunit.Sdk;
 
 namespace Tests.Model_UTs
 {
-    internal class PlayerManagerTest
+    public class PlayerManagerTest
     {
-        // TODO test that Player's copy constructer enables isolated changes
+        [Fact]
+        public void TestConstructorReturnsEmptyHashSet()
+        {
+            // Arrange
+            PlayerManager playerManager;
+            HashSet<Player> expected;
+            HashSet<Player> actual;
+
+            // Act
+            playerManager = new();
+            expected = new();
+            actual = (HashSet<Player>)playerManager.GetAll();
+
+            // Assert
+            Assert.Equal(expected, actual);
+        }
+
+        [Fact]
+        public void TestAddIfPlayersThenDoAddAndReturnPlayers()
+        {
+            // Arrange
+            PlayerManager playerManager = new();
+            Player alice = new("Alice");
+            Player bob = new("Bob");
+            HashSet<Player> expected = new() { alice, bob };
+
+            // Act
+            HashSet<Player> actual = new()
+            {
+                playerManager.Add(ref alice),
+                playerManager.Add(ref bob)
+            };
+
+            // Assert
+            Assert.Equal(expected, actual);
+        }
+
+        [Fact]
+        public void TestAddIfNullThenDontAddAndReturnNull()
+        {
+            // Arrange
+            PlayerManager playerManager = new();
+            Player expected;
+            Player actual;
+
+            // Act
+            expected = null;
+            actual = playerManager.Add(ref expected);
+
+            // Assert
+            Assert.Equal(expected, actual);
+            Assert.DoesNotContain(expected, playerManager.GetAll());
+        }
+
+        // TODO update if we do implement it
+        [Fact]
+        public void TestGetOneByIdThrowsNotImplemented()
+        {
+            // Arrange
+            PlayerManager playerManager = new();
+
+            // Act
+            void action() => playerManager.GetOneById(1);
+
+            // Assert
+            Assert.Throws<NotImplementedException>(action);
+        }
+
+        [Theory]
+        [InlineData("")]
+        [InlineData(null)]
+        [InlineData(" ")]
+        public void TestGetOneByNameIfInvalidThenReturnNull(string name)
+        {
+            // Arrange
+            PlayerManager playerManager = new();
+            Player player = new("Bob");
+            playerManager.Add(ref player);
+
+            // Act
+            Player result = playerManager.GetOneByName(name);
+
+            // Assert
+            Assert.Null(result);
+        }
+
+        [Fact]
+        public void TestGetOneByNameIfValidButNotExistThenReturnNull()
+        {
+            // Arrange
+            PlayerManager playerManager = new();
+            Player player = new("Bob");
+            playerManager.Add(ref player);
+
+            // Act
+            Player result = playerManager.GetOneByName("Clyde");
+
+            // Assert
+            Assert.Null(result);
+        }
+
+        [Theory]
+        [InlineData("Bob")]
+        [InlineData("bob")]
+        [InlineData("bob ")]
+        [InlineData(" boB ")]
+        public void TestGetOneByNameIfValidThenReturnPlayer(string name)
+        {
+            // Arrange
+            PlayerManager playerManager = new();
+            Player expected = new("Bob");
+            playerManager.Add(ref expected);
+
+            // Act
+            Player actual = playerManager.GetOneByName(name);
+
+            // Assert
+            Assert.Equal(expected, actual);
+        }
+
+        [Fact]
+        public void TestRemoveWorksIfExists()
+        {
+            // Arrange
+            PlayerManager playerManager = new();
+            Player p1 = new("Dylan");
+            playerManager.Add(ref p1);
+
+            // Act
+            playerManager.Remove(ref p1);
+
+            // Assert
+            Assert.DoesNotContain(p1, playerManager.GetAll());
+        }
+
+        [Fact]
+        public void TestRemoveFailsSilentlyIfGivenNull()
+        {
+            // Arrange
+            PlayerManager playerManager = new();
+            Player player = new("Dylan");
+            playerManager.Add(ref player);
+            Player notPlayer = null;
+            HashSet<Player> expected = new() { player };
+
+            // Act
+            playerManager.Remove(ref notPlayer);
+            HashSet<Player> actual = (HashSet<Player>)playerManager.GetAll();
+
+            // Assert
+            Assert.Equal(actual, expected);
+        }
+
+        [Fact]
+        public void TestRemoveFailsSilentlyIfGivenNonExistent()
+        {
+            // Arrange
+            PlayerManager playerManager = new();
+            Player player = new("Dylan");
+            playerManager.Add(ref player);
+            Player notPlayer = new("Eric");
+            HashSet<Player> expected = new() { player };
+
+            // Act
+            playerManager.Remove(ref notPlayer);
+            HashSet<Player> actual = (HashSet<Player>)playerManager.GetAll();
+
+            // Assert
+            Assert.Equal(actual, expected);
+        }
+
+        [Fact]
+        public void TestUpdateWorksIfValid()
+        {
+            // Arrange
+            PlayerManager playerManager = new();
+            Player oldPlayer = new("Dylan");
+            playerManager.Add(ref oldPlayer);
+            Player newPlayer = new("Eric");
+
+            // Act
+            playerManager.Update(ref oldPlayer, ref newPlayer);
+
+            // Assert
+            Assert.DoesNotContain(oldPlayer, playerManager.GetAll());
+            Assert.Contains(newPlayer, playerManager.GetAll());
+        }
     }
 }

Sources/Tests/Model_UTs/PlayerTest.cs

@@ -20,26 +20,28 @@ namespace Tests.Model_UTs
         }
 
         [Fact]
-        public void TestConstructorIfWhitespaceThenException()
+        public void TestConstructorIfNameUntrimmedThenTrimmedName()
         {
             // Arrange
             Player player;
 
             // Act
-            void action() => player = new(" ");
+            player = new("Alice ");
 
             // Assert
-            Assert.Throws<ArgumentException>(action);
+            Assert.Equal("Alice", player.Name);
         }
 
-        [Fact]
-        public void TestConstructorIfBlankThenException()
+        [Theory]
+        [InlineData("")]
+        [InlineData(" ")]
+        public void TestConstructorIfWhitespaceOrBlankThenException(string name)
         {
             // Arrange
             Player player;
 
             // Act
-            void action() => player = new("");
+            void action() => player = new(name);
 
             // Assert
             Assert.Throws<ArgumentException>(action);
@@ -100,7 +102,7 @@ namespace Tests.Model_UTs
         }
 
         [Fact]
-        public void TestGoesThruIfObjIsPlayer()
+        public void TestGoesThruToSecondMethodIfObjIsTypePlayer()
         {
             // Arrange
             Object p1;
@@ -132,8 +134,11 @@ namespace Tests.Model_UTs
             Assert.False(p2.Equals(p1));
         }
 
-        [Fact]
-        public void TestEqualsTrueIfSameNameDifferentCase()
+        [Theory]
+        [InlineData("devoN")]
+        [InlineData(" devon")]
+        [InlineData("deVon ")]
+        public void TestEqualsTrueIfSameNameDifferentCaseOrSpace(string name)
         {
             // Arrange
             Player p1;
@@ -141,7 +146,7 @@ namespace Tests.Model_UTs
 
             // Act
             p1 = new("Devon");
-            p2 = new("devoN");
+            p2 = new(name);
 
             // Assert
             Assert.True(p1.Equals(p2));
@@ -180,16 +185,20 @@ namespace Tests.Model_UTs
             Assert.False(p2.GetHashCode().Equals(p1.GetHashCode()));
         }
 
-        [Fact]
-        public void TestSameHashTrueIfSameNameDifferentCase()
+        [Theory]
+        [InlineData("devoN", "devon")]
+        [InlineData(" devon", "devon")]
+        [InlineData("DevoN ", "devon")]
+        [InlineData(" dEvoN ", "devon")]
+        public void TestSameHashTrueIfSameNameDifferentCase(string name1, string name2)
         {
             // Arrange
             Player p1;
             Player p2;
 
             // Act
-            p1 = new("Devon");
-            p2 = new("devoN");
+            p1 = new(name1);
+            p2 = new(name2);
 
             // Assert
             Assert.True(p1.GetHashCode().Equals(p2.GetHashCode()));
@@ -220,7 +229,7 @@ namespace Tests.Model_UTs
             Player p2;
 
             // Act
-            p1 = new("Elyse");
+            p1 = new(" Elyse ");
             p2 = new(p1);
 
             // Assert