Agrego test de turn.cs y waitinglist.cs

test/LibraryTests/DomainClassesTests/TurnTests.cs

@@ -1,70 +1,92 @@
 using ClassLibrary;
 using NUnit.Framework;
 
-namespace ClassLibrary.Tests;
-
-// public class TurnTests
-// {
-//     [Test]
-//     public void TurnInitialization_ReturnsPlayer1_CurrentPlayer()
-//     {
-//         Player player1 = new Player();
-//         Player player2 = new Player();
-//
-//         Turn turn = new Turn(player1, player2);
-//
-//         Assert.That(turn.CurrentPlayer, Is.EqualTo(player1));
-//     }
-//     [Test]
-//     public void TurnInitialization_ReturnsPlayer2_WaitingPlayer()
-//     {
-//         Player player1 = new Player();
-//         Player player2 = new Player();
-//         Turn turn = new Turn(player1, player2);
-//         Assert.That(turn.WaitingPlayer, Is.EqualTo(player2));
-//     }
-//     [Test]
-//     public void ChangeTurn_ShouldSwitchPlayers()
-//     {
-//          // Act
-//         Player player1 = new Player();
-//         Player player2 = new Player();
-//         Turn turn = new Turn(player1, player2);
-//         turn.ChangeTurn();
-//          // Assert
-//         Assert.That(turn.WaitingPlayer, Is.EqualTo(player1));
-//         Assert.That(turn.CurrentPlayer, Is.EqualTo(player2));
-//     }
-//         [Test]
-//         public void PenalizeTurn_ShouldChangeTurn_WhenCurrentPlayerIsPenalized()
-//         {
-//             // Arrange
-//             Player player1 = new Player();
-//             Player player2 = new Player();
-//             Turn turn = new Turn(player1, player2);
-//
-//             // Act
-//             turn.PenalizeTurn(player1);
-//             
-//             // Assert
-//             Assert.That(player1, Is.EqualTo(turn.WaitingPlayer));
-//             Assert.That(player2, Is.EqualTo(turn.CurrentPlayer));
-//         }
-//
-//         [Test]
-//         public void PenalizeTurn_ShouldChangeTurn_WhenWaitingPlayerIsPenalized()
-//         {
-//             // Act
-//             Player player1 = new Player();
-//             Player player2 = new Player();
-//             Turn turn = new Turn(player1, player2);
-//             turn.ChangeTurn();
-//             turn.PenalizeTurn(player2);
-//
-//             // Assert
-//             Assert.That(player2, Is.EqualTo(turn.WaitingPlayer));
-//             Assert.That(player1, Is.EqualTo(turn.CurrentPlayer));
-//         }
-//
-//
-// }
+namespace ClassLibrary.Tests
+{
+    public class TurnTests
+    {
+        private Turn turn;
+        private Player _player1;
+        private Player _player2;
+
+        [SetUp]
+        public void Setup()
+        {
+            _player1 = new Player("Player 1");
+            _player2 = new Player("Player 2");
+            turn = new Turn(_player1, _player2);
+        }
+
+        [Test]
+        public void Constructor_NullPlayer1_ThrowsArgumentNullException()
+        {
+            // Act & Assert
+            Assert.That(() => new Turn(null, _player2), Throws.ArgumentNullException);
+        }
+
+        [Test]
+        public void Constructor_NullPlayer2_ThrowsArgumentNullException()
+        {
+            // Act & Assert
+            Assert.That(() => new Turn(_player1, null), Throws.ArgumentNullException);
+        }
+
+        [Test]
+        public void Constructor_ValidPlayers_InitializesCurrentAndWaitingPlayers()
+        {
+            // Assert
+            Assert.That(turn.CurrentPlayer, Is.EqualTo(_player1));
+            Assert.That(turn.WaitingPlayer, Is.EqualTo(_player2));
+        }
+
+        [Test]
+        public void ChangeTurn_SwitchesCurrentAndWaitingPlayers()
+        {
+            // Act
+            turn.ChangeTurn();
+
+            // Assert
+            Assert.That(turn.CurrentPlayer, Is.EqualTo(_player2));
+            Assert.That(turn.WaitingPlayer, Is.EqualTo(_player1));
+        }
+
+        [Test]
+        public void PenalizeTurn_CurrentPlayer_ChangesTurn()
+        {
+            // Arrange
+            var initialCurrentPlayer = turn.CurrentPlayer;
+
+            // Act
+            turn.PenalizeTurn(turn.CurrentPlayer);
+
+            // Assert
+            Assert.That(turn.CurrentPlayer, Is.Not.EqualTo(initialCurrentPlayer));
+        }
+
+        [Test]
+        public void PenalizeTurn_WaitingPlayer_DoesNotChangeTurn()
+        {
+            // Arrange
+            var initialCurrentPlayer = turn.CurrentPlayer;
+
+            // Act
+            turn.PenalizeTurn(turn.WaitingPlayer);
+
+            // Assert
+            Assert.That(turn.CurrentPlayer, Is.EqualTo(initialCurrentPlayer));
+        }
+
+        [Test]
+        public void PenalizeTurn_NullPlayer_DoesNotChangeTurn()
+        {
+            // Arrange
+            var initialCurrentPlayer = turn.CurrentPlayer;
+
+            // Act
+            turn.PenalizeTurn(null);
+
+            // Assert
+            Assert.That(turn.CurrentPlayer, Is.EqualTo(initialCurrentPlayer));
+        }
+    }
+}

test/LibraryTests/DomainClassesTests/WaitingListTests.cs

@@ -1,6 +1,182 @@
-namespace ClassLibrary.Tests;
+using ClassLibrary;
+using NUnit.Framework;
+using System.Collections.ObjectModel;
 
-public class WaitingListTests
+namespace ClassLibrary.Tests
 {
-
-}
+    public class WaitingListTests
+    {
+        private WaitingList waitingList;
+
+        [SetUp]
+        public void Setup()
+        {
+            waitingList = new WaitingList();
+        }
+
+        [Test]
+        public void AddPlayer_ValidDisplayName_ReturnsTrueAndAddsPlayer()
+        {
+            // Act
+            bool result = waitingList.AddPlayer("Player1");
+
+            // Assert
+            Assert.That(result, Is.True);
+            Assert.That(waitingList.Count, Is.EqualTo(1));
+            Assert.That(waitingList.FindPlayerByDisplayName("Player1"), Is.Not.Null);
+        }
+
+        [Test]
+        public void AddPlayer_NullOrEmptyDisplayName_ThrowsArgumentException()
+        {
+            // Act & Assert
+            Assert.That(() => waitingList.AddPlayer(null), Throws.ArgumentException);
+            Assert.That(() => waitingList.AddPlayer(""), Throws.ArgumentException);
+        }
+
+        [Test]
+        public void AddPlayer_DisplayNameAlreadyExists_ReturnsFalse()
+        {
+            // Arrange
+            waitingList.AddPlayer("Player1");
+
+            // Act
+            bool result = waitingList.AddPlayer("Player1");
+
+            // Assert
+            Assert.That(result, Is.False);
+            Assert.That(waitingList.Count, Is.EqualTo(1));
+        }
+
+        [Test]
+        public void RemovePlayer_ValidDisplayName_ReturnsTrueAndRemovesPlayer()
+        {
+            // Arrange
+            waitingList.AddPlayer("Player1");
+
+            // Act
+            bool result = waitingList.RemovePlayer("Player1");
+
+            // Assert
+            Assert.That(result, Is.True);
+            Assert.That(waitingList.Count, Is.EqualTo(0));
+            Assert.That(waitingList.FindPlayerByDisplayName("Player1"), Is.Null);
+        }
+
+        [Test]
+        public void RemovePlayer_NullOrEmptyDisplayName_ThrowsArgumentException()
+        {
+            // Act & Assert
+            Assert.That(() => waitingList.RemovePlayer(null), Throws.ArgumentException);
+            Assert.That(() => waitingList.RemovePlayer(""), Throws.ArgumentException);
+        }
+
+        [Test]
+        public void RemovePlayer_DisplayNameDoesNotExist_ReturnsFalse()
+        {
+            // Act
+            bool result = waitingList.RemovePlayer("NonExistentPlayer");
+
+            // Assert
+            Assert.That(result, Is.False);
+            Assert.That(waitingList.Count, Is.EqualTo(0));
+        }
+
+        [Test]
+        public void FindPlayerByDisplayName_ValidDisplayName_ReturnsPlayer()
+        {
+            // Arrange
+            waitingList.AddPlayer("Player1");
+
+            // Act
+            Player foundPlayer = waitingList.FindPlayerByDisplayName("Player1");
+
+            // Assert
+            Assert.That(foundPlayer, Is.Not.Null);
+            Assert.That(foundPlayer.DisplayName, Is.EqualTo("Player1"));
+        }
+
+        [Test]
+        public void FindPlayerByDisplayName_NullOrEmptyDisplayName_ThrowsArgumentException()
+        {
+            // Act & Assert
+            Assert.That(() => waitingList.FindPlayerByDisplayName(null), Throws.ArgumentException);
+            Assert.That(() => waitingList.FindPlayerByDisplayName(""), Throws.ArgumentException);
+        }
+
+        [Test]
+        public void FindPlayerByDisplayName_DisplayNameDoesNotExist_ReturnsNull()
+        {
+            // Act
+            Player foundPlayer = waitingList.FindPlayerByDisplayName("NonExistentPlayer");
+
+            // Assert
+            Assert.That(foundPlayer, Is.Null);
+        }
+
+        [Test]
+        public void GetAllWaiting_NoPlayers_ReturnsEmptyCollection()
+        {
+            // Act
+            ReadOnlyCollection<Player> players = waitingList.GetAllWaiting();
+
+            // Assert
+            Assert.That(players, Is.Empty);
+        }
+
+        [Test]
+        public void GetAllWaiting_PlayersExist_ReturnsAllPlayers()
+        {
+            // Arrange
+            waitingList.AddPlayer("Player1");
+            waitingList.AddPlayer("Player2");
+
+            // Act
+            ReadOnlyCollection<Player> players = waitingList.GetAllWaiting();
+
+            // Assert
+            Assert.That(players.Count, Is.EqualTo(2));
+            Assert.That(players[0].DisplayName, Is.EqualTo("Player1"));
+            Assert.That(players[1].DisplayName, Is.EqualTo("Player2"));
+        }
+
+        [Test]
+        public void GetAnyoneWaiting_NoPlayers_ReturnsNull()
+        {
+            // Act
+            Player player = waitingList.GetAnyoneWaiting();
+
+            // Assert
+            Assert.That(player, Is.Null);
+        }
+
+        [Test]
+        public void GetAnyoneWaiting_PlayersExist_ReturnsFirstPlayer()
+        {
+            // Arrange
+            waitingList.AddPlayer("Player1");
+            waitingList.AddPlayer("Player2");
+
+            // Act
+            Player player = waitingList.GetAnyoneWaiting();
+
+            // Assert
+            Assert.That(player, Is.Not.Null);
+            Assert.That(player.DisplayName, Is.EqualTo("Player1"));
+        }
+
+        [Test]
+        public void Count_PropertyReflectsNumberOfPlayers()
+        {
+            // Arrange
+            waitingList.AddPlayer("Player1");
+            waitingList.AddPlayer("Player2");
+
+            // Act
+            int count = waitingList.Count;
+
+            // Assert
+            Assert.That(count, Is.EqualTo(2));
+        }
+    }
+}