Split up methods in controllers, added tests for GameService, refactored GameGroup name to Game and directory Game to GameStuff

BackendTests/Controllers/GameControllerTests.cs

@@ -5,7 +5,7 @@ using System.Text.Json;
 using Microsoft.Extensions.Logging;
 using NSubstitute;
 using pacMan.Controllers;
-using pacMan.Game;
+using pacMan.GameStuff;
 using pacMan.Services;
 using pacMan.Utils;
 

BackendTests/Game/Items/DiceCupTests.cs

@@ -1,4 +1,4 @@
-using pacMan.Game.Items;
+using pacMan.GameStuff.Items;
 
 namespace BackendTests.Game.Items;
 
@@ -11,7 +11,7 @@ public class DiceCupTests
         var roll = diceCup.Roll;
         Assert.That(roll, Has.Count.EqualTo(2));
     }
-    
+
     [Test]
     public void Roll_ReturnsNumbersInRange1To6()
     {

BackendTests/Game/Items/DiceTests.cs

@@ -1,4 +1,4 @@
-using pacMan.Game.Items;
+using pacMan.GameStuff.Items;
 
 namespace BackendTests.Game.Items;
 

BackendTests/Services/ActionServiceTests.cs

@@ -2,8 +2,8 @@ using System.Text.Json;
 using BackendTests.TestUtils;
 using Microsoft.Extensions.Logging;
 using NSubstitute;
-using pacMan.Game;
-using pacMan.Game.Items;
+using pacMan.GameStuff;
+using pacMan.GameStuff.Items;
 using pacMan.Services;
 
 namespace BackendTests.Services;
@@ -171,7 +171,8 @@ public class ActionServiceTests
     [Test]
     public void Ready_TwoReady()
     {
-        var group = new GameGroup(new Queue<DirectionalPosition>()) { Players = { _blackPlayer, _whitePlayer } };
+        var group = new pacMan.Services.Game(new Queue<DirectionalPosition>())
+            { Players = { _blackPlayer, _whitePlayer } };
         _service.Group = group;
         _service.Player = _blackPlayer;
 
@@ -194,7 +195,7 @@ public class ActionServiceTests
     [Test]
     public void FindNextPlayer_NoPlayers()
     {
-        _service.Group = new GameGroup(new Queue<DirectionalPosition>());
+        _service.Group = new pacMan.Services.Game(new Queue<DirectionalPosition>());
         Assert.Throws<InvalidOperationException>(() => _service.FindNextPlayer());
     }
 
@@ -202,7 +203,7 @@ public class ActionServiceTests
     public void FindNextPlayer_OnePlayer()
     {
         _service.Group =
-            new GameGroup(new Queue<DirectionalPosition>(
+            new pacMan.Services.Game(new Queue<DirectionalPosition>(
                     new[] { new DirectionalPosition { At = new Position { X = 3, Y = 3 }, Direction = Direction.Up } }))
                 { Players = { _whitePlayer } };
 
@@ -213,7 +214,7 @@ public class ActionServiceTests
     [Test]
     public void FindNextPlayer_TwoPlayers()
     {
-        _service.Group = new GameGroup(new Queue<DirectionalPosition>(
+        _service.Group = new pacMan.Services.Game(new Queue<DirectionalPosition>(
             new[]
             {
                 new DirectionalPosition { At = new Position { X = 3, Y = 3 }, Direction = Direction.Up },

BackendTests/Services/GameServiceTests.cs

@@ -0,0 +1,100 @@
+using BackendTests.TestUtils;
+using Microsoft.Extensions.Logging;
+using NSubstitute;
+using pacMan.Exceptions;
+using pacMan.GameStuff;
+using pacMan.Services;
+
+namespace BackendTests.Services;
+
+public class GameServiceTests
+{
+    private readonly DirectionalPosition _spawn3By3Up = new()
+        { At = new Position { X = 3, Y = 3 }, Direction = Direction.Up };
+
+    private GameService _service = null!;
+    private Queue<DirectionalPosition> _spawns = null!;
+
+    [SetUp]
+    public void SetUp()
+    {
+        _service = new GameService(Substitute.For<ILogger<GameService>>());
+        _spawns = new Queue<DirectionalPosition>(new[]
+        {
+            _spawn3By3Up,
+            new DirectionalPosition { At = new Position { X = 7, Y = 7 }, Direction = Direction.Down },
+            new DirectionalPosition { At = new Position { X = 7, Y = 7 }, Direction = Direction.Down },
+            new DirectionalPosition { At = new Position { X = 7, Y = 7 }, Direction = Direction.Down }
+        });
+    }
+
+    #region JoinbyId(Guid id)
+
+    [Test]
+    public void JoinById_WhenIdNotExists()
+    {
+        var player = Players.Create("white");
+        _service.AddPlayer(player, _spawns);
+
+        Assert.Throws<GameNotFoundException>(() => _service.JoinById(Guid.NewGuid(), player));
+    }
+    
+    [Test]
+    public void JoinById_WhenIdExists()
+    {
+        var player = Players.Create("white");
+        var group = _service.AddPlayer(player, _spawns);
+
+        var player2 = Players.Create("black");
+        var result = _service.JoinById(group.Id, player2);
+
+        Assert.Multiple(() =>
+        {
+            Assert.That(result, Is.EqualTo(group));
+            Assert.That(group.Players, Has.Count.EqualTo(2));
+            Assert.That(_service.Games, Has.Count.EqualTo(1));
+        });
+    }
+
+    #endregion
+
+    #region AddPlayer(IPlayer)
+
+    [Test]
+    public void AddPlayer_ToEmptyGroup()
+    {
+        var player = Players.Create("white");
+        var group = _service.AddPlayer(player, _spawns);
+
+        Assert.Multiple(() =>
+        {
+            Assert.That(group.Players, Has.Count.EqualTo(1));
+            Assert.That(group.NextPlayer, Is.EqualTo(player));
+            Assert.That(_service.Games, Has.Count.EqualTo(1));
+        });
+    }
+
+    [Test]
+    public void AddPlayer_ToFullGroup()
+    {
+        for (var i = 0; i < 4; i++)
+        {
+            var player = Players.Create(i.ToString());
+            _service.AddPlayer(player, _spawns);
+        }
+
+        var player5 = Players.Create("white");
+
+        var group = _service.AddPlayer(player5, new Queue<DirectionalPosition>(new[] { _spawn3By3Up }));
+
+        Assert.Multiple(() =>
+        {
+            Assert.That(group.Players, Has.Count.EqualTo(1));
+            Assert.That(group.NextPlayer, Is.EqualTo(player5));
+            Assert.That(_service.Games, Has.Count.EqualTo(2));
+            Assert.That(_service.Games.First(), Has.Count.EqualTo(Rules.MaxPlayers));
+        });
+    }
+
+    #endregion
+}

BackendTests/Services/GameTests.cs

@@ -1,13 +1,12 @@
 using BackendTests.TestUtils;
 using pacMan.Exceptions;
-using pacMan.Game;
-using pacMan.Game.Items;
-using pacMan.Services;
+using pacMan.GameStuff;
+using pacMan.GameStuff.Items;
 using pacMan.Utils;
 
 namespace BackendTests.Services;
 
-public class GameGroupTests
+public class GameTests
 {
     private readonly DirectionalPosition _spawn3By3Up = new()
         { At = new Position { X = 3, Y = 3 }, Direction = Direction.Up };
@@ -22,7 +21,7 @@ public class GameGroupTests
         { At = new Position { X = 7, Y = 7 }, Direction = Direction.Right };
 
     private IPlayer _bluePlayer = null!;
-    private GameGroup _gameGroup = null!;
+    private pacMan.Services.Game _game = null!;
     private IPlayer _greenPlayer = null!;
     private IPlayer _purplePlayer = null!;
     private IPlayer _redPlayer = null!;
@@ -36,7 +35,7 @@ public class GameGroupTests
         _spawns = new Queue<DirectionalPosition>(
             new[] { _spawn3By3Up, _spawn7By7Left, _spawn7By7Down, _spawn7By7Right });
 
-        _gameGroup = new GameGroup(_spawns);
+        _game = new pacMan.Services.Game(_spawns);
         _redPlayer = Players.Create("red");
         _bluePlayer = Players.Create("blue");
         _yellowPlayer = Players.Create("yellow");
@@ -46,10 +45,10 @@ public class GameGroupTests
 
     private void AddFullParty()
     {
-        _gameGroup.AddPlayer(_bluePlayer);
-        _gameGroup.AddPlayer(_redPlayer);
-        _gameGroup.AddPlayer(_yellowPlayer);
-        _gameGroup.AddPlayer(_greenPlayer);
+        _game.AddPlayer(_bluePlayer);
+        _game.AddPlayer(_redPlayer);
+        _game.AddPlayer(_yellowPlayer);
+        _game.AddPlayer(_greenPlayer);
     }
 
     #region NextPlayer()
@@ -57,7 +56,7 @@ public class GameGroupTests
     [Test]
     public void NextPlayer_WhenEmpty()
     {
-        Assert.Throws<InvalidOperationException>(() => _gameGroup.NextPlayer());
+        Assert.Throws<InvalidOperationException>(() => _game.NextPlayer());
     }
 
     #endregion
@@ -67,7 +66,7 @@ public class GameGroupTests
     [Test]
     public void AddPlayer_WhenEmpty()
     {
-        var added = _gameGroup.AddPlayer(_redPlayer);
+        var added = _game.AddPlayer(_redPlayer);
         Assert.That(added, Is.True);
     }
 
@@ -76,16 +75,16 @@ public class GameGroupTests
         Assert.Multiple(() =>
         {
             AddFullParty();
-            Assert.That(_gameGroup.Players.Count, Is.EqualTo(Rules.MaxPlayers));
-            Assert.That(_gameGroup.AddPlayer(_purplePlayer), Is.False);
+            Assert.That(_game.Players.Count, Is.EqualTo(Rules.MaxPlayers));
+            Assert.That(_game.AddPlayer(_purplePlayer), Is.False);
         });
 
     [Test]
     public void AddPlayer_WhenNameExists()
     {
         var redClone = Players.Clone(_redPlayer);
-        _gameGroup.AddPlayer(_redPlayer);
-        var added = _gameGroup.AddPlayer(redClone);
+        _game.AddPlayer(_redPlayer);
+        var added = _game.AddPlayer(redClone);
         Assert.That(added, Is.True);
     }
 
@@ -93,14 +92,14 @@ public class GameGroupTests
     public void AddPlayer_WhenStateIsNotWaitingForPlayers()
     {
         _redPlayer.State = State.InGame;
-        _gameGroup.AddPlayer(_redPlayer);
+        _game.AddPlayer(_redPlayer);
         Assert.That(_redPlayer.State, Is.EqualTo(State.WaitingForPlayers));
     }
 
     [Test]
     public void AddPlayer_AddSpawnPosition()
     {
-        _gameGroup.AddPlayer(_redPlayer);
+        _game.AddPlayer(_redPlayer);
         Assert.That(_redPlayer.PacMan.SpawnPosition, Is.Not.Null);
         Assert.That(_redPlayer.PacMan.SpawnPosition, Is.EqualTo(_spawn3By3Up));
     }
@@ -108,16 +107,16 @@ public class GameGroupTests
     [Test]
     public void AddPlayer_WhenGameHasStarted()
     {
-        _gameGroup.AddPlayer(_redPlayer);
-        _gameGroup.AddPlayer(_bluePlayer);
+        _game.AddPlayer(_redPlayer);
+        _game.AddPlayer(_bluePlayer);
 
-        _gameGroup.SetReady(_redPlayer);
-        _gameGroup.SetReady(_bluePlayer);
-        _gameGroup.SetAllInGame();
-        
-        Assert.That(_gameGroup.AddPlayer(_greenPlayer), Is.False);
+        _game.SetReady(_redPlayer);
+        _game.SetReady(_bluePlayer);
+        _game.SetAllInGame();
+
+        Assert.That(_game.AddPlayer(_greenPlayer), Is.False);
     }
-    
+
     #endregion
 
     #region Sendtoall(ArraySegment<byte> segment)
@@ -125,7 +124,7 @@ public class GameGroupTests
     [Test]
     public void SendToAll_WhenConnectionsIsNull()
     {
-        Assert.DoesNotThrow(() => _gameGroup.SendToAll(new { }.ToArraySegment()));
+        Assert.DoesNotThrow(() => _game.SendToAll(new { }.ToArraySegment()));
     }
 
     [Test]
@@ -134,10 +133,10 @@ public class GameGroupTests
         var counter = 0;
         async Task Send(ArraySegment<byte> segment) => await Task.Run(() => counter++);
 
-        _gameGroup.Connections += Send;
-        _gameGroup.Connections += Send;
+        _game.Connections += Send;
+        _game.Connections += Send;
 
-        _gameGroup.SendToAll(new { }.ToArraySegment());
+        _game.SendToAll(new { }.ToArraySegment());
 
         // TODO timeout after n amount of time
         while (counter < 2) { }
@@ -152,10 +151,10 @@ public class GameGroupTests
     [Test]
     public void SetReady_ReturnsAllPlayers()
     {
-        _gameGroup.AddPlayer(_redPlayer);
-        _gameGroup.AddPlayer(_bluePlayer);
+        _game.AddPlayer(_redPlayer);
+        _game.AddPlayer(_bluePlayer);
 
-        var players = _gameGroup.SetReady(_redPlayer).ToList();
+        var players = _game.SetReady(_redPlayer).ToList();
 
         Assert.Multiple(() =>
         {
@@ -168,11 +167,11 @@ public class GameGroupTests
     [Test]
     public void SetReady_SetsStateToReady()
     {
-        _gameGroup.AddPlayer(_redPlayer);
+        _game.AddPlayer(_redPlayer);
 
         Assert.That(_redPlayer.State, Is.Not.EqualTo(State.Ready));
 
-        _gameGroup.SetReady(_redPlayer);
+        _game.SetReady(_redPlayer);
 
         Assert.That(_redPlayer.State, Is.EqualTo(State.Ready));
     }
@@ -180,7 +179,7 @@ public class GameGroupTests
     [Test]
     public void SetReady_WhenPlayerIsNotInPlayers()
     {
-        Assert.Throws<PlayerNotFoundException>(() => _gameGroup.SetReady(_redPlayer));
+        Assert.Throws<PlayerNotFoundException>(() => _game.SetReady(_redPlayer));
     }
 
     #endregion
@@ -191,15 +190,15 @@ public class GameGroupTests
     public void SetAllInGame_SetsStateToInGame()
     {
         AddFullParty();
-        _gameGroup.Players.ForEach(player => player.State = State.Ready);
-        Assert.That(_gameGroup.Players, Has.All.Property(nameof(IPlayer.State)).EqualTo(State.Ready));
+        _game.Players.ForEach(player => player.State = State.Ready);
+        Assert.That(_game.Players, Has.All.Property(nameof(IPlayer.State)).EqualTo(State.Ready));
 
-        var allInGame = _gameGroup.SetAllInGame();
+        var allInGame = _game.SetAllInGame();
 
         Assert.Multiple(() =>
         {
             Assert.That(allInGame, Is.True);
-            Assert.That(_gameGroup.Players, Has.All.Property(nameof(IPlayer.State)).EqualTo(State.InGame));
+            Assert.That(_game.Players, Has.All.Property(nameof(IPlayer.State)).EqualTo(State.InGame));
         });
     }
 
@@ -207,15 +206,15 @@ public class GameGroupTests
     public void SetAllInGame_SetStateToInGame_WhenNotAllReady()
     {
         AddFullParty();
-        var allInGame = _gameGroup.SetAllInGame();
+        var allInGame = _game.SetAllInGame();
         Assert.That(allInGame, Is.False);
     }
 
     [Test]
     public void SetAllInGame_WhenPlayersIsEmpty()
     {
-        _gameGroup.SetAllInGame();
-        Assert.That(_gameGroup.Players, Is.Empty);
+        _game.SetAllInGame();
+        Assert.That(_game.Players, Is.Empty);
     }
 
     #endregion
@@ -226,15 +225,15 @@ public class GameGroupTests
     public void IsGameStarted_AllWaiting()
     {
         AddFullParty();
-        Assert.That(_gameGroup.IsGameStarted, Is.False);
+        Assert.That(_game.IsGameStarted, Is.False);
     }
 
     [Test]
     public void IsGameStarted_AllInGame()
     {
         AddFullParty();
-        _gameGroup.Players.ForEach(player => player.State = State.InGame);
-        Assert.That(_gameGroup.IsGameStarted, Is.True);
+        _game.Players.ForEach(player => player.State = State.InGame);
+        Assert.That(_game.IsGameStarted, Is.True);
     }
 
     #endregion

BackendTests/Services/WebSocketServiceTests.cs

@@ -1,8 +1,7 @@
 using System.Net.WebSockets;
-using BackendTests.TestUtils;
 using Microsoft.Extensions.Logging;
 using NSubstitute;
-using pacMan.Game;
+using pacMan.Interfaces;
 using pacMan.Services;
 using pacMan.Utils;
 
@@ -10,25 +9,12 @@ namespace BackendTests.Services;
 
 public class WebSocketServiceTests
 {
-    private readonly DirectionalPosition _spawn3By3Up = new()
-        { At = new Position { X = 3, Y = 3 }, Direction = Direction.Up };
-
-    private GameService _service = null!;
-
-    private Queue<DirectionalPosition> _spawns = null!;
-
+    private IWebSocketService _service = null!;
 
     [SetUp]
     public void SetUp()
     {
-        _service = new GameService(Substitute.For<ILogger<GameService>>());
-        _spawns = new Queue<DirectionalPosition>(new[]
-        {
-            _spawn3By3Up,
-            new DirectionalPosition { At = new Position { X = 7, Y = 7 }, Direction = Direction.Down },
-            new DirectionalPosition { At = new Position { X = 7, Y = 7 }, Direction = Direction.Down },
-            new DirectionalPosition { At = new Position { X = 7, Y = 7 }, Direction = Direction.Down }
-        });
+        _service = new WebSocketService(Substitute.For<ILogger<WebSocketService>>());
     }
 
     #region Send(Websocket, ArraySegment<byte>)
@@ -140,44 +126,4 @@ public class WebSocketServiceTests
     }
 
     #endregion
-
-    #region AddPlayer(IPlayer)
-
-    [Test]
-    public void AddPlayer_ToEmptyGroup()
-    {
-        var player = Players.Create("white");
-        var group = _service.AddPlayer(player, _spawns);
-
-        Assert.Multiple(() =>
-        {
-            Assert.That(group.Players, Has.Count.EqualTo(1));
-            Assert.That(group.NextPlayer, Is.EqualTo(player));
-            Assert.That(_service.Games, Has.Count.EqualTo(1));
-        });
-    }
-
-    [Test]
-    public void AddPlayer_ToFullGroup()
-    {
-        for (var i = 0; i < 4; i++)
-        {
-            var player = Players.Create(i.ToString());
-            _service.AddPlayer(player, _spawns);
-        }
-
-        var player5 = Players.Create("white");
-
-        var group = _service.AddPlayer(player5, new Queue<DirectionalPosition>(new[] { _spawn3By3Up }));
-
-        Assert.Multiple(() =>
-        {
-            Assert.That(group.Players, Has.Count.EqualTo(1));
-            Assert.That(group.NextPlayer, Is.EqualTo(player5));
-            Assert.That(_service.Games, Has.Count.EqualTo(2));
-            Assert.That(_service.Games.First(), Has.Count.EqualTo(Rules.MaxPlayers));
-        });
-    }
-
-    #endregion
 }

BackendTests/TestUtils/Players.cs

@@ -1,5 +1,5 @@
-using pacMan.Game;
-using pacMan.Game.Items;
+using pacMan.GameStuff;
+using pacMan.GameStuff.Items;
 
 namespace BackendTests.TestUtils;