Merge pull request '♻️ Fix #120 add-gamemanager' (#125) from add-gamemanager into main

Reviewed-on: #125

Sources/App/Program.cs

@@ -19,16 +19,16 @@ namespace App
         {
             // MODEL stuff
             ILoader loader = new Stub();
-            GameRunner gameRunner;
+            MasterOfCeremonies masterOfCeremonies;
             try
             {
-                gameRunner = loader.LoadApp();
+                masterOfCeremonies = loader.LoadApp();
             }
             catch (Exception ex)
             {
                 Console.WriteLine(ex.Message);
                 Console.WriteLine(ex.StackTrace);
-                gameRunner = new(new PlayerManager(), new DieManager(), null);
+                masterOfCeremonies = new(new PlayerManager(), new DieManager(), null);
             }
 
             try
@@ -48,7 +48,7 @@ namespace App
                         try
                         {
                             // persist them  as models !
-                            gameRunner.GlobalPlayerManager.Add(entity.ToModel());
+                            masterOfCeremonies.GlobalPlayerManager.Add(entity.ToModel());
                             Debug.WriteLine($"{entity.ID} -- {entity.Name}");
                         }
                         catch (Exception ex) { Debug.WriteLine($"{ex.Message}\n... Never mind"); }
@@ -81,38 +81,38 @@ namespace App
                         break;
 
                     case "l":
-                        string loadName = ChooseGame(gameRunner);
+                        string loadName = ChooseGame(masterOfCeremonies);
-                        if (gameRunner.GetOneByName(loadName) != null)
+                        if (masterOfCeremonies.GameManager.GetOneByName(loadName) != null)
                         {
-                            Play(gameRunner, loadName);
+                            Play(masterOfCeremonies, loadName);
                         }
                         break;
 
                     case "n":
 
-                        if (!gameRunner.GlobalDieManager.GetAll().Any())
+                        if (!masterOfCeremonies.DieGroupManager.GetAll().Any())
                         {
                             Console.WriteLine("make at least one dice group first, then try again");
                             break;
                         }
                         Console.WriteLine("add dice to the game");
-                        IEnumerable<Die> newGameDice = PrepareDice(gameRunner);
+                        IEnumerable<Die> newGameDice = PrepareDice(masterOfCeremonies);
 
                         string newGameName;
                         Console.WriteLine("give this new game a name\n>");
                         newGameName = Console.ReadLine();
 
                         Console.WriteLine("add players to the game");
-                        PlayerManager playerManager = PreparePlayers(gameRunner);
+                        PlayerManager playerManager = PreparePlayers(masterOfCeremonies);
 
-                        gameRunner.StartNewGame(newGameName, playerManager, newGameDice);
+                        masterOfCeremonies.StartNewGame(newGameName, playerManager, newGameDice);
-                        Play(gameRunner, newGameName);
+                        Play(masterOfCeremonies, newGameName);
 
                         break;
 
                     case "d":
-                        string deleteName = ChooseGame(gameRunner);
+                        string deleteName = ChooseGame(masterOfCeremonies);
-                        gameRunner.Remove(gameRunner.GetOneByName(deleteName));
+                        masterOfCeremonies.GameManager.Remove(masterOfCeremonies.GameManager.GetOneByName(deleteName));
                         break;
 
                     case "c":
@@ -151,19 +151,19 @@ namespace App
                                 newGroupDice.Add(die);
                             }
                         }
-                        gameRunner.GlobalDieManager.Add(new KeyValuePair<string, IEnumerable<Die>>(newGroupName, newGroupDice));
+                        masterOfCeremonies.DieGroupManager.Add(new KeyValuePair<string, IEnumerable<Die>>(newGroupName, newGroupDice));
                         break;
 
                     case "p":
-                        ShowPlayers(gameRunner);
+                        ShowPlayers(masterOfCeremonies);
                         break;
 
                     case "i":
-                        ShowDice(gameRunner);
+                        ShowDice(masterOfCeremonies);
                         break;
 
                     case "y":
-                        PreparePlayers(gameRunner);
+                        PreparePlayers(masterOfCeremonies);
                         break;
 
                     default:
@@ -178,7 +178,7 @@ namespace App
                 using (DiceAppDbContext db = new())
                 {
                     // get all the players from the app's memory
-                    IEnumerable<Player> models = gameRunner.GlobalPlayerManager.GetAll();
+                    IEnumerable<Player> models = masterOfCeremonies.GlobalPlayerManager.GetAll();
 
                     // create a PlayerDbManager (and inject it with the DB)
                     PlayerDbManager playerDbManager = new(db);
@@ -197,15 +197,16 @@ namespace App
                         catch (ArgumentException ex) { Debug.WriteLine($"{ex.Message}\n... Never mind"); }
                     }
                 }
-            } catch (Exception ex) { Debug.WriteLine($"{ex.Message}\n... Couldn't use the database"); }
+            }
+            catch (Exception ex) { Debug.WriteLine($"{ex.Message}\n... Couldn't use the database"); }
         }
 
-        private static void Play(GameRunner gameRunner, string name)
+        private static void Play(MasterOfCeremonies masterOfCeremonies, string name)
         {
             string menuChoicePlay = "";
             while (menuChoicePlay != "q")
             {
-                Game game = gameRunner.GetOneByName(name);
+                Game game = masterOfCeremonies.GameManager.GetOneByName(name);
                 Console.WriteLine($"{game.GetWhoPlaysNow()}'s turn\n" +
                     "q... quit\n" +
                     "h... show history\n" +
@@ -223,21 +224,21 @@ namespace App
                         }
                         break;
                     case "s":
-                        gameRunner.Add(game);
+                        masterOfCeremonies.GameManager.Add(game);
                         break;
                     default:
-                        GameRunner.PlayGame(game);
+                        MasterOfCeremonies.PlayGame(game);
                         Console.WriteLine(game.GetHistory().Last());
                         break;
                 }
             }
         }
 
-        private static string ChooseGame(GameRunner gameRunner)
+        private static string ChooseGame(MasterOfCeremonies masterOfCeremonies)
         {
             string name;
             Console.WriteLine("which of these games?\n(choose by name)\n>");
-            foreach (Game game in gameRunner.GetAll())
+            foreach (Game game in masterOfCeremonies.GameManager.GetAll())
             {
                 Console.WriteLine(game);
             }
@@ -245,18 +246,18 @@ namespace App
             return name;
         }
 
-        private static void ShowPlayers(GameRunner gameRunner)
+        private static void ShowPlayers(MasterOfCeremonies masterOfCeremonies)
         {
             Console.WriteLine("Look at all them players!");
-            foreach (Player player in gameRunner.GlobalPlayerManager.GetAll())
+            foreach (Player player in masterOfCeremonies.GlobalPlayerManager.GetAll())
             {
                 Console.WriteLine(player);
             }
         }
 
-        private static void ShowDice(GameRunner gameRunner)
+        private static void ShowDice(MasterOfCeremonies masterOfCeremonies)
         {
-            foreach ((string name, IEnumerable<Die> dice) in gameRunner.GlobalDieManager.GetAll())
+            foreach ((string name, IEnumerable<Die> dice) in masterOfCeremonies.DieGroupManager.GetAll())
             {
                 Console.WriteLine($"{name} -- {dice}");
             }
@@ -332,11 +333,11 @@ namespace App
             return die;
         }
 
-        private static IEnumerable<Die> PrepareDice(GameRunner gameRunner)
+        private static IEnumerable<Die> PrepareDice(MasterOfCeremonies masterOfCeremonies)
         {
             List<Die> result = new();
             Console.WriteLine("all known dice or groups of dice:");
-            ShowDice(gameRunner);
+            ShowDice(masterOfCeremonies);
             string menuChoiceDice = "";
             while (!(menuChoiceDice.Equals("ok") && result.Any()))
             {
@@ -344,7 +345,7 @@ namespace App
                 menuChoiceDice = Console.ReadLine();
                 if (!menuChoiceDice.Equals("ok"))
                 {
-                    IEnumerable<Die> chosenDice = gameRunner.GlobalDieManager.GetOneByName(menuChoiceDice).Value;
+                    IEnumerable<Die> chosenDice = masterOfCeremonies.DieGroupManager.GetOneByName(menuChoiceDice).Value;
                     foreach (Die die in chosenDice)
                     {
                         result.Add(die);
@@ -353,11 +354,11 @@ namespace App
             }
             return result.AsEnumerable();
         }
-        private static PlayerManager PreparePlayers(GameRunner gameRunner)
+        private static PlayerManager PreparePlayers(MasterOfCeremonies masterOfCeremonies)
         {
             PlayerManager result = new();
             Console.WriteLine("all known players:");
-            ShowPlayers(gameRunner);
+            ShowPlayers(masterOfCeremonies);
             string menuChoicePlayers = "";
             while (!(menuChoicePlayers.Equals("ok") && result.GetAll().Any()))
             {
@@ -366,10 +367,10 @@ namespace App
                 if (!menuChoicePlayers.Equals("ok"))
                 {
                     Player player = new(menuChoicePlayers);
-                    if (!gameRunner.GlobalPlayerManager.GetAll().Contains(player))
+                    if (!masterOfCeremonies.GlobalPlayerManager.GetAll().Contains(player))
                     {
                         // if the player didn't exist, now it does... this is temporary
-                        gameRunner.GlobalPlayerManager.Add(player);
+                        masterOfCeremonies.GlobalPlayerManager.Add(player);
                     }
                     // almost no checks, this is temporary
                     try

Sources/Data/EF/DiceAppDbContext.cs

@@ -6,7 +6,7 @@ namespace Data.EF
 {
     public class DiceAppDbContext : DbContext, ILoader
     {
-        public virtual GameRunner LoadApp() { throw new NotImplementedException(); }
+        public virtual MasterOfCeremonies LoadApp() { throw new NotImplementedException(); }
 
         public DbSet<PlayerEntity> Players { get; set; }
 

Sources/Data/EF/DiceAppDbContextWithStub.cs

@@ -7,7 +7,7 @@ namespace Data.EF
 {
     public class DiceAppDbContextWithStub : DiceAppDbContext
     {
-        public override GameRunner LoadApp() { throw new NotImplementedException(); }
+        public override MasterOfCeremonies LoadApp() { throw new NotImplementedException(); }
 
         public DiceAppDbContextWithStub() { }
 

Sources/Data/ILoader.cs

@@ -4,6 +4,6 @@ namespace Data
 {
     public interface ILoader
     {
-        public GameRunner LoadApp();
+        public MasterOfCeremonies LoadApp();
     }
 }

Sources/Data/Stub.cs

@@ -8,9 +8,9 @@ namespace Data
 {
     public class Stub : ILoader
     {
-        public GameRunner LoadApp()
+        public MasterOfCeremonies LoadApp()
         {
-            GameRunner gr = new(new PlayerManager(), new DieManager());
+            MasterOfCeremonies gr = new(new PlayerManager(), new DieManager(), new GameManager());
 
             Player player1 = new("Alice(Old Stub)"), player2 = new("Bob(Old Stub)"), player3 = new("Clyde(Old Stub)");
 
@@ -63,26 +63,26 @@ namespace Data
 
             dndDice.Add(new NumberDie(d20Faces));
 
-            gr.GlobalDieManager.Add(new KeyValuePair<string, IEnumerable<Die>>(dndName, dndDice.AsEnumerable()));
+            gr.DieGroupManager.Add(new KeyValuePair<string, IEnumerable<Die>>(dndName, dndDice.AsEnumerable()));
-            gr.GlobalDieManager.Add(new KeyValuePair<string, IEnumerable<Die>>(monopolyName, monopolyDice.AsEnumerable()));
+            gr.DieGroupManager.Add(new KeyValuePair<string, IEnumerable<Die>>(monopolyName, monopolyDice.AsEnumerable()));
 
             string game1 = "Forgotten Realms", game2 = "4e", game3 = "The Coopers";
 
-            gr.Add(new(game1, new PlayerManager(), dndDice.AsEnumerable()));
+            gr.GameManager.Add(new(game1, new PlayerManager(), dndDice.AsEnumerable()));
-            gr.Add(new(game2, new PlayerManager(), dndDice.AsEnumerable()));
+            gr.GameManager.Add(new(game2, new PlayerManager(), dndDice.AsEnumerable()));
-            gr.Add(new(game3, new PlayerManager(), monopolyDice.AsEnumerable()));
+            gr.GameManager.Add(new(game3, new PlayerManager(), monopolyDice.AsEnumerable()));
 
-            gr.GetOneByName(game1).PlayerManager.Add(player1);
+            gr.GameManager.GetOneByName(game1).PlayerManager.Add(player1);
-            gr.GetOneByName(game1).PlayerManager.Add(player2);
+            gr.GameManager.GetOneByName(game1).PlayerManager.Add(player2);
 
-            gr.GetOneByName(game2).PlayerManager.Add(player1);
+            gr.GameManager.GetOneByName(game2).PlayerManager.Add(player1);
-            gr.GetOneByName(game2).PlayerManager.Add(player2);
+            gr.GameManager.GetOneByName(game2).PlayerManager.Add(player2);
-            gr.GetOneByName(game2).PlayerManager.Add(player3);
+            gr.GameManager.GetOneByName(game2).PlayerManager.Add(player3);
 
-            gr.GetOneByName(game3).PlayerManager.Add(player1);
+            gr.GameManager.GetOneByName(game3).PlayerManager.Add(player1);
-            gr.GetOneByName(game3).PlayerManager.Add(player3);
+            gr.GameManager.GetOneByName(game3).PlayerManager.Add(player3);
 
-            foreach (Game game in gr.GetAll())
+            foreach (Game game in gr.GameManager.GetAll())
             {
                 for (int i = 0; i < 10; i++)
                 {

Sources/Model/Games/Game.cs

@@ -19,7 +19,7 @@ namespace Model.Games
             {
                 return name;
             }
-            set // GameRunner will need to take care of forbidding
+            set // MasterOfCeremonies will need to take care of forbidding
                 // (or allowing) having two Games with the same name etc.
             {
                 if (string.IsNullOrWhiteSpace(value))

Sources/Model/Games/GameManager.cs

@@ -1,34 +1,31 @@
-using Model.Dice;
+using System;
-using Model.Players;
-using System;
 using System.Collections.Generic;
 using System.Linq;
 
 namespace Model.Games
 {
-    public class GameRunner : IManager<Game>
+    public class GameManager : IManager<Game>
     {
-        public IManager<Player> GlobalPlayerManager { get; private set; }
+        /// <summary>
-        public IManager<KeyValuePair<string, IEnumerable<Die>>> GlobalDieManager { get; private set; }
+        /// the games managed by this instance
+        /// </summary>
         private readonly List<Game> games;
 
-        public GameRunner(IManager<Player> globalPlayerManager, IManager<KeyValuePair<string, IEnumerable<Die>>> globalDieManager, List<Game> games)
+        public GameManager()
         {
-            GlobalPlayerManager = globalPlayerManager;
+            games = new();
-            GlobalDieManager = globalDieManager;
-            this.games = games ?? new();
         }
 
-        public GameRunner(IManager<Player> globalPlayerManager, IManager<KeyValuePair<string, IEnumerable<Die>>> globalDieManager)
+        /// <summary>
-            : this(globalPlayerManager, globalDieManager, null) { }
+        /// gets an unmodifiable collection of the games
-
+        /// </summary>
-
+        /// <returns>unmodifiable collection of the games</returns>
         public IEnumerable<Game> GetAll() => games.AsEnumerable();
 
         /// <summary>
         /// finds the game with that name and returns it
         /// <br/>
-        /// that copy does not belong to this gamerunner's games, so it should not be modified 
+        /// that copy does not belong to this manager's games, so it should not be modified 
         /// </summary>
         /// <param name="name">a games's name</param>
         /// <returns>game with said name, <em>or null</em> if no such game was found</returns>
@@ -42,6 +39,17 @@ namespace Model.Games
             throw new ArgumentException("param should not be null or blank", nameof(name));
         }
 
+        /// <summary>
+        /// not implemented in the model
+        /// </summary>
+        /// <param name="ID"></param>
+        /// <returns></returns>
+        /// <exception cref="NotImplementedException"></exception>
+        public Game GetOneByID(Guid ID)
+        {
+            throw new NotImplementedException();
+        }
+
         /// <summary>
         /// saves a given game -- does not allow copies yet: if a game with the same name exists, it is overwritten
         /// </summary>
@@ -60,14 +68,10 @@ namespace Model.Games
         }
 
         /// <summary>
-        /// creates a new game
+        /// removes a game. does nothing if the game doesn't exist
         /// </summary>
-        public Game StartNewGame(string name, IManager<Player> playerManager, IEnumerable<Die> dice)
+        /// <param name="toRemove">game to remove</param>
-        {
+        /// <exception cref="ArgumentNullException"></exception>
-            Game game = new(name, playerManager, dice);
-            return Add(game);
-        }
-
         public void Remove(Game toRemove)
         {
             if (toRemove is null)
@@ -77,6 +81,13 @@ namespace Model.Games
             games.Remove(toRemove);
         }
 
+        /// <summary>
+        /// updates a game
+        /// </summary>
+        /// <param name="before">original game</param>
+        /// <param name="after">new game</param>
+        /// <returns></returns>
+        /// <exception cref="ArgumentNullException"></exception>
         public Game Update(Game before, Game after)
         {
 
@@ -94,21 +105,5 @@ namespace Model.Games
             Remove(before);
             return Add(after);
         }
-
-        /// <summary>
-        /// plays one turn of the game
-        /// </summary>
-        /// <param name="game">the game from which a turn will be played</param>
-        public static void PlayGame(Game game)
-        {
-            Player current = game.GetWhoPlaysNow();
-            game.PerformTurn(current);
-            game.PrepareNextPlayer(current);
-        }
-
-        public Game GetOneByID(Guid ID)
-        {
-            throw new NotImplementedException();
-        }
     }
 }

Sources/Model/Games/MasterOfCeremonies.cs

@@ -0,0 +1,45 @@
+using Model.Dice;
+using Model.Players;
+using System.Collections.Generic;
+
+namespace Model.Games
+{
+    public class MasterOfCeremonies
+    {
+        public IManager<Player> GlobalPlayerManager { get; private set; }
+        public IManager<KeyValuePair<string, IEnumerable<Die>>> DieGroupManager { get; private set; }
+        public IManager<Game> GameManager { get; private set; }
+
+        public MasterOfCeremonies(IManager<Player> globalPlayerManager, IManager<KeyValuePair<string, IEnumerable<Die>>> globalDieManager, IManager<Game> gameManager)
+        {
+            GlobalPlayerManager = globalPlayerManager;
+            DieGroupManager = globalDieManager;
+            GameManager = gameManager;
+        }
+
+        /// <summary>
+        /// creates a new game
+        /// </summary>
+        /// <param name="name"></param>
+        /// <param name="playerManager"></param>
+        /// <param name="dice"></param>
+        /// <returns></returns>
+        public Game StartNewGame(string name, IManager<Player> playerManager, IEnumerable<Die> dice)
+        {
+            Game game = new(name, playerManager, dice);
+            return GameManager.Add(game);
+        }
+
+        /// <summary>
+        /// plays one turn of the game
+        /// </summary>
+        /// <param name="game">the game from which a turn will be played</param>
+        public static void PlayGame(Game game)
+        {
+            Player current = game.GetWhoPlaysNow();
+            game.PerformTurn(current);
+            game.PrepareNextPlayer(current);
+        }
+
+    }
+}

Sources/Tests/Model_UTs/Games/GameManagerTest.cs

@@ -0,0 +1,281 @@
+using Data;
+using Model;
+using Model.Dice;
+using Model.Games;
+using Model.Players;
+using System;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Xunit;
+
+namespace Tests.Model_UTs.Games
+{
+    public class GameManagerTest
+    {
+        private readonly MasterOfCeremonies stubGameRunner = new Stub().LoadApp();
+
+        [Fact]
+        public void TestConstructorReturnsEmptyEnumerable()
+        {
+            // Arrange
+            GameManager gm = new();
+            IEnumerable<Game> expected;
+            IEnumerable<Game> actual;
+
+            // Act
+            expected = new Collection<Game>();
+            actual = gm.GetAll();
+
+            // Assert
+            Assert.Equal(expected, actual);
+        }
+
+        [Fact]
+        public void TestAddWhenGamesThenDoAddAndReturnGames()
+        {
+            // Arrange
+            GameManager gm = new();
+            Game game1 = stubGameRunner.GameManager.GetAll().First();
+            Game game2 = stubGameRunner.GameManager.GetAll().Last();
+
+            // Act
+            IEnumerable<Game> expected = new List<Game>() { game1, game2 }.AsEnumerable();
+            IEnumerable<Game> actual = new List<Game>()
+            {
+                gm.Add(game1),
+                gm.Add(game2)
+            };
+
+            // Assert
+            Assert.Equal(expected, actual);
+        }
+
+        [Fact]
+        public void TestAddWhenNullThenThrowsException()
+        {
+            // Arrange
+            GameManager gm = new();
+
+            // Act
+            void action() => gm.Add(null);// Add() returns the added element if succesful
+
+            // Assert
+            Assert.Throws<ArgumentNullException>(action);
+            Assert.DoesNotContain(null, stubGameRunner.GameManager.GetAll());
+        }
+
+        [Fact]
+        public void TestGetOneByIdThrowsException()
+        {
+            // Arrange
+            GameManager gm = new();
+
+            // Act
+
+            void action() => gm.GetOneByID(Guid.NewGuid());
+
+            // Assert
+            Assert.Throws<NotImplementedException>(action);
+        }
+
+        [Theory]
+        [InlineData("")]
+        [InlineData(null)]
+        [InlineData(" ")]
+        public void TestGetOneByNameWhenInvalidThenThrowsException(string name)
+        {
+            // Arrange
+            GameManager gm = new();
+
+            // Act
+            void action() => gm.GetOneByName(name);
+
+            // Assert
+            Assert.Throws<ArgumentException>(action);
+        }
+
+        [Fact]
+        public void TestGetOneByNameWhenValidButNotExistThenReturnNull()
+        {
+            // Arrange
+            GameManager gm = new();
+
+            // Act
+            Game result = gm.GetOneByName("thereisbasicallynowaythatthisgamenamealreadyexists");
+
+            // Assert
+            Assert.Null(result);
+        }
+
+        [Fact]
+        public void TestGetOneByNameWhenValidThenReturnGame()
+        {
+            // Arrange
+            GameManager gm = new();
+            Game game = stubGameRunner.GameManager.GetAll().First();
+
+            // Act
+            Game actual = gm.Add(game);
+            Game expected = game;
+
+            // Assert
+            Assert.Equal(expected, actual);
+        }
+
+        [Fact]
+        public void TestWhenRemoveExistsThenSucceeds()
+        {
+            // Arrange
+            GameManager gm = new();
+
+            Game game = new("blargh", new PlayerManager(), stubGameRunner.GameManager.GetAll().First().Dice);
+            gm.Add(game);
+
+            // Act
+            gm.Remove(game);
+
+            // Assert
+            Assert.DoesNotContain(game, gm.GetAll());
+        }
+
+        [Fact]
+        public void TestRemoveWhenGivenNullThenThrowsException()
+        {
+            // Arrange
+            GameManager gm = new();
+
+            // Act
+            void action() => gm.Remove(null);
+
+            // Assert
+            Assert.Throws<ArgumentNullException>(action);
+        }
+
+        [Fact]
+        public void TestRemoveWhenGivenNonExistentThenFailsSilently()
+        {
+            // Arrange
+            IManager<Game> gm = stubGameRunner.GameManager;
+
+            Game notGame = new("blargh", new PlayerManager(), stubGameRunner.GameManager.GetAll().First().Dice);
+            IEnumerable<Game> expected = stubGameRunner.GameManager.GetAll();
+
+            // Act
+            gm.Remove(notGame);
+            IEnumerable<Game> actual = gm.GetAll();
+
+            // Assert
+            Assert.Equal(actual, expected);
+        }
+
+        [Fact]
+        public void TestUpdateWhenValidThenSucceeds()
+        {
+            // Arrange
+            GameManager gm = new();
+
+            string oldName = "blargh";
+            string newName = "blargh2.0";
+            Game game = new(oldName, new PlayerManager(), stubGameRunner.GameManager.GetAll().First().Dice);
+            game.PlayerManager.Add(new("Alice"));
+            gm.Add(game);
+
+            Game oldGame = gm.GetAll().First();
+            Game newGame = new(newName, oldGame.PlayerManager, oldGame.Dice);
+
+            // Act
+            int expectedSize = gm.GetAll().Count();
+            gm.Update(oldGame, newGame);
+            int actualSize = gm.GetAll().Count();
+
+            // Assert
+            Assert.NotEqual(oldName, newName);
+            Assert.DoesNotContain(oldGame, gm.GetAll());
+            Assert.Contains(newGame, gm.GetAll());
+            Assert.Equal(expectedSize, actualSize);
+        }
+
+        [Theory]
+        [InlineData("")]
+        [InlineData(" ")]
+        [InlineData(null)]
+        public void TestUpdateWhenValidBeforeAndInvalidAfterThenDoesNotGo(string badName)
+        {
+            // Arrange
+            IManager<Game> gm = stubGameRunner.GameManager;
+
+            int expectedSize = gm.GetAll().Count();
+            Game oldGame = gm.GetAll().First();
+
+            // Act
+            void action() => gm.Update(oldGame, new(badName, oldGame.PlayerManager, oldGame.Dice));
+            int actualSize = gm.GetAll().Count();
+
+            // Assert
+            Assert.Throws<ArgumentException>(action); // thrown by constructor
+            Assert.Contains(oldGame, gm.GetAll()); // still there
+            Assert.Equal(expectedSize, actualSize);
+        }
+
+        [Fact]
+        public void TestUpdateWhenValidBeforeAndNullAfterThenDoesNotGo()
+        {
+            // Arrange
+            IManager<Game> gm = stubGameRunner.GameManager;
+            int expectedSize = gm.GetAll().Count();
+            Game oldGame = gm.GetAll().First();
+
+            // Act
+            void action() => gm.Update(oldGame, null);
+            int actualSize = gm.GetAll().Count();
+
+            // Assert
+            Assert.Throws<ArgumentNullException>(action); // thrown by constructor
+            Assert.Contains(oldGame, gm.GetAll()); // still there
+            Assert.True(expectedSize == actualSize);
+        }
+
+        [Fact]
+        public void TestUpdateDoesNotGoWithValidAfterAndNullBefore()
+        {
+            // Arrange
+            IManager<Game> gm = stubGameRunner.GameManager;
+            int expectedSize = gm.GetAll().Count();
+            Game oldGame = gm.GetAll().First();
+
+            // Act
+            void action() => gm.Update(null, new("newgamename", oldGame.PlayerManager, oldGame.Dice));
+            int actualSize = gm.GetAll().Count();
+
+            // Assert
+            Assert.Throws<ArgumentNullException>(action); // thrown by constructor
+            Assert.Contains(oldGame, gm.GetAll()); // still there
+            Assert.True(expectedSize == actualSize);
+        }
+
+        [Theory]
+        [InlineData("")]
+        [InlineData(" ")]
+        [InlineData(null)]
+        public void TestUpdateWhenInvalidBeforeAndValidAfterThenDoesNotGo(string badName)
+        {
+            // Arrange
+            IManager<Game> gm = stubGameRunner.GameManager;
+            int expectedSize = gm.GetAll().Count();
+            Game oldGame = gm.GetAll().First();
+
+            // Act
+            void action() => gm.Update(new(badName, oldGame.PlayerManager, oldGame.Dice), new("valid", oldGame.PlayerManager, oldGame.Dice));
+            int actualSize = gm.GetAll().Count();
+
+            // Assert
+            Assert.Throws<ArgumentException>(action); // thrown by constructor
+            Assert.Contains(oldGame, gm.GetAll()); // still there
+            Assert.True(expectedSize == actualSize);
+        }
+
+    }
+}

Sources/Tests/Model_UTs/Games/GameRunnerTest.cs

@@ -1,319 +0,0 @@
-using Data;
-using Model.Dice;
-using Model.Games;
-using Model.Players;
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using Xunit;
-
-namespace Tests.Model_UTs.Games
-{
-    public class GameRunnerTest
-    {
-        private readonly GameRunner stubGameRunner = new Stub().LoadApp();
-
-        [Fact]
-        public void TestConstructorWhenNoGamesThenNewIEnumerable()
-        {
-            // Arrange
-            GameRunner gameRunner = new(new PlayerManager(), new DieManager());
-            IEnumerable<Game> expected;
-            IEnumerable<Game> actual;
-
-            // Act
-            expected = new List<Game>().AsEnumerable();
-            actual = gameRunner.GetAll();
-
-            // Assert
-            Assert.Equal(expected, actual);
-        }
-
-        [Fact]
-        public void TestConstructorWhenGamesThenGamesIEnumerable()
-        {
-            // Arrange
-            GameRunner gameRunner = new(new PlayerManager(), new DieManager(), stubGameRunner.GetAll().ToList());
-            IEnumerable<Game> expected;
-            IEnumerable<Game> actual;
-
-            // Act
-            expected = stubGameRunner.GetAll();
-            actual = gameRunner.GetAll();
-
-            // Assert
-            Assert.Equal(expected, actual);
-        }
-
-        [Fact]
-        public void TestAddWhenGamesThenDoAddAndReturnGames()
-        {
-            // Arrange
-            GameRunner gameRunner = new(new PlayerManager(), new DieManager());
-            Game game1 = stubGameRunner.GetAll().First();
-            Game game2 = stubGameRunner.GetAll().Last();
-
-            // Act
-            IEnumerable<Game> expected = new List<Game>() { game1, game2 }.AsEnumerable();
-            IEnumerable<Game> actual = new List<Game>()
-            {
-                gameRunner.Add(game1),
-                gameRunner.Add(game2)
-            };
-
-            // Assert
-            Assert.Equal(expected, actual);
-        }
-
-        [Fact]
-        public void TestAddWhenNullThenThrowsException()
-        {
-            // Arrange
-            GameRunner gameRunner = stubGameRunner;
-
-            // Act
-            void action() => gameRunner.Add(null);// Add() returns the added element if succesful
-
-            // Assert
-            Assert.Throws<ArgumentNullException>(action);
-            Assert.DoesNotContain(null, stubGameRunner.GetAll());
-        }
-
-        [Fact]
-        public void TestGetOneByIdThrowsException()
-        {
-            // Arrange
-            GameRunner gameRunner = stubGameRunner;
-
-            // Act
-
-            void action() => gameRunner.GetOneByID(new("62bb72e6-f9fb-442e-a879-e1b70f8f52f3"));
-
-            // Assert
-            Assert.Throws<NotImplementedException>(action);
-        }
-
-        [Theory]
-        [InlineData("")]
-        [InlineData(null)]
-        [InlineData(" ")]
-        public void TestGetOneByNameWhenInvalidThenThrowsException(string name)
-        {
-            // Arrange
-            GameRunner gameRunner = stubGameRunner;
-
-            // Act
-            void action() => gameRunner.GetOneByName(name);
-
-            // Assert
-            Assert.Throws<ArgumentException>(action);
-        }
-
-        [Fact]
-        public void TestGetOneByNameWhenValidButNotExistThenReturnNull()
-        {
-            // Arrange
-            GameRunner gameRunner = stubGameRunner;
-
-            // Act
-            Game result = gameRunner.GetOneByName("thereisbasicallynowaythatthisgamenamealreadyexists");
-
-            // Assert
-            Assert.Null(result);
-        }
-
-        [Fact]
-        public void TestGetOneByNameWhenValidThenReturnGame()
-        {
-            // Arrange
-            GameRunner gameRunner = new(new PlayerManager(), new DieManager());
-            Game game = stubGameRunner.GetAll().First();
-
-            // Act
-            Game actual = gameRunner.Add(game);
-            Game expected = game;
-
-            // Assert
-            Assert.Equal(expected, actual);
-        }
-
-        [Fact]
-        public void TestWhenRemoveExistsThenSucceeds()
-        {
-            // Arrange
-            GameRunner gameRunner = stubGameRunner;
-            Game game = new("blargh", new PlayerManager(), gameRunner.GetAll().First().Dice);
-            gameRunner.Add(game);
-
-            // Act
-            gameRunner.Remove(game);
-
-            // Assert
-            Assert.DoesNotContain(game, gameRunner.GetAll());
-        }
-
-        [Fact]
-        public void TestRemoveWhenGivenNullThenThrowsException()
-        {
-            // Arrange
-            GameRunner gameRunner = stubGameRunner;
-
-            // Act
-            void action() => gameRunner.Remove(null);
-
-            // Assert
-            Assert.Throws<ArgumentNullException>(action);
-        }
-
-        [Fact]
-        public void TestRemoveWhenGiveenNonExistentThenFailsSilently()
-        {
-            // Arrange
-            GameRunner gameRunner = stubGameRunner;
-            Game notGame = new("blargh", new PlayerManager(), gameRunner.GetAll().First().Dice);
-            IEnumerable<Game> expected = gameRunner.GetAll();
-
-            // Act
-            gameRunner.Remove(notGame);
-            IEnumerable<Game> actual = gameRunner.GetAll();
-
-            // Assert
-            Assert.Equal(actual, expected);
-        }
-
-        [Fact]
-        public void TestUpdateWhenValidThenSucceeds()
-        {
-            // Arrange
-            string oldName = "blargh";
-            string newName = "blargh2.0";
-            GameRunner gameRunner = new(new PlayerManager(), new DieManager());
-            Game game = new(oldName, new PlayerManager(), stubGameRunner.GetAll().First().Dice);
-            game.PlayerManager.Add(new("Alice"));
-            gameRunner.Add(game);
-
-            Game oldGame = gameRunner.GetAll().First();
-            Game newGame = new(newName, oldGame.PlayerManager, oldGame.Dice);
-
-            // Act
-            int oldSize = gameRunner.GetAll().Count();
-            gameRunner.Update(oldGame, newGame);
-            int newSize = gameRunner.GetAll().Count();
-
-            // Assert
-            Assert.NotEqual(oldName, newName);
-            Assert.DoesNotContain(oldGame, gameRunner.GetAll());
-            Assert.Contains(newGame, gameRunner.GetAll());
-            Assert.Equal(oldSize, newSize);
-        }
-
-        [Theory]
-        [InlineData("")]
-        [InlineData(" ")]
-        [InlineData(null)]
-        public void TestUpdateWhenValidBeforeAndInvalidAfterThenDoesNotGo(string badName)
-        {
-            // Arrange
-            GameRunner gameRunner = stubGameRunner;
-            int expectedSize = gameRunner.GetAll().Count();
-            Game oldGame = gameRunner.GetAll().First();
-
-            // Act
-            void action() => gameRunner.Update(oldGame, new(badName, oldGame.PlayerManager, oldGame.Dice));
-            int actualSize = gameRunner.GetAll().Count();
-
-            // Assert
-            Assert.Throws<ArgumentException>(action); // thrown by constructor
-            Assert.Contains(oldGame, gameRunner.GetAll()); // still there
-            Assert.True(expectedSize == actualSize);
-        }
-
-        [Fact]
-        public void TestUpdateWhenValidBeforeAndNullAfterThenDoesNotGo()
-        {
-            // Arrange
-            GameRunner gameRunner = stubGameRunner;
-            int expectedSize = gameRunner.GetAll().Count();
-            Game oldGame = gameRunner.GetAll().First();
-
-            // Act
-            void action() => gameRunner.Update(oldGame, null);
-            int actualSize = gameRunner.GetAll().Count();
-
-            // Assert
-            Assert.Throws<ArgumentNullException>(action); // thrown by constructor
-            Assert.Contains(oldGame, gameRunner.GetAll()); // still there
-            Assert.True(expectedSize == actualSize);
-        }
-
-        [Fact]
-        public void TestUpdateDoesNotGoWithValidAfterAndNullBefore()
-        {
-            // Arrange
-            GameRunner gameRunner = stubGameRunner;
-            int expectedSize = gameRunner.GetAll().Count();
-            Game oldGame = gameRunner.GetAll().First();
-
-            // Act
-            void action() => gameRunner.Update(null, new("newgamename", oldGame.PlayerManager, oldGame.Dice));
-            int actualSize = gameRunner.GetAll().Count();
-
-            // Assert
-            Assert.Throws<ArgumentNullException>(action); // thrown by constructor
-            Assert.Contains(oldGame, gameRunner.GetAll()); // still there
-            Assert.True(expectedSize == actualSize);
-        }
-
-        [Theory]
-        [InlineData("")]
-        [InlineData(" ")]
-        [InlineData(null)]
-        public void TestUpdateWhenInvalidBeforeAndValidAfterThenDoesNotGo(string badName)
-        {
-            // Arrange
-            GameRunner gameRunner = stubGameRunner;
-            int expectedSize = gameRunner.GetAll().Count();
-            Game oldGame = gameRunner.GetAll().First();
-
-            // Act
-            void action() => gameRunner.Update(new(badName, oldGame.PlayerManager, oldGame.Dice), new("valid", oldGame.PlayerManager, oldGame.Dice));
-            int actualSize = gameRunner.GetAll().Count();
-
-            // Assert
-            Assert.Throws<ArgumentException>(action); // thrown by constructor
-            Assert.Contains(oldGame, gameRunner.GetAll()); // still there
-            Assert.True(expectedSize == actualSize);
-        }
-
-        [Fact]
-        public void TestPlayGameWhenPlayThenAddNewTurnToHistory()
-        {
-            // Arrange
-            GameRunner gameRunner = stubGameRunner;
-            Game game = gameRunner.GetAll().First();
-
-            // Act
-            int turnsBefore = game.GetHistory().Count();
-            GameRunner.PlayGame(game);
-            int turnsAfter = game.GetHistory().Count();
-
-            // Assert
-            Assert.Equal(turnsBefore + 1, turnsAfter);
-        }
-
-        [Fact]
-        public void TestStartNewGame()
-        {
-            // Arrange
-            GameRunner gameRunner = stubGameRunner;
-            string name = "blargh";
-
-            // Act
-            Assert.DoesNotContain(gameRunner.GetOneByName(name), gameRunner.GetAll());
-            gameRunner.StartNewGame(name, new PlayerManager(), stubGameRunner.GetAll().First().Dice);
-
-            // Assert
-            Assert.Contains(gameRunner.GetOneByName(name), gameRunner.GetAll());
-        }
-    }
-}

Sources/Tests/Model_UTs/Games/GameTest.cs

@@ -13,15 +13,15 @@ namespace Tests.Model_UTs.Games
 {
     public class GameTest
     {
-        private readonly GameRunner stubGameRunner = new Stub().LoadApp();
+        private readonly MasterOfCeremonies stubMasterOfCeremonies = new Stub().LoadApp();
         private static readonly string GAME_NAME = "my game";
 
         private static readonly Player PLAYER_1 = new("Alice"), PLAYER_2 = new("Bob"), PLAYER_3 = new("Clyde");
         private readonly IEnumerable<Die> DICE_1, DICE_2;
         public GameTest()
         {
-            DICE_1 = stubGameRunner.GlobalDieManager.GetAll().First().Value;
+            DICE_1 = stubMasterOfCeremonies.DieGroupManager.GetAll().First().Value;
-            DICE_2 = stubGameRunner.GlobalDieManager.GetAll().Last().Value;
+            DICE_2 = stubMasterOfCeremonies.DieGroupManager.GetAll().Last().Value;
         }
 
 
@@ -81,7 +81,7 @@ namespace Tests.Model_UTs.Games
         public void TestGetHistory()
         {
             // Arrange
-            Dictionary<Die, Face> diceNFaces = (Dictionary<Die, Face>)stubGameRunner.GetAll().First().GetHistory().First().DiceNFaces;
+            Dictionary<Die, Face> diceNFaces = (Dictionary<Die, Face>)stubMasterOfCeremonies.GameManager.GetAll().First().GetHistory().First().DiceNFaces;
 
             Turn turn1 = Turn.CreateWithDefaultTime(PLAYER_1, diceNFaces);
             Turn turn2 = Turn.CreateWithDefaultTime(PLAYER_2, diceNFaces); // yeah they rolled the same

Sources/Tests/Model_UTs/Games/MasterOfCeremoniesTest.cs

@@ -0,0 +1,47 @@
+using Data;
+using Model.Dice;
+using Model.Games;
+using Model.Players;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using Xunit;
+
+namespace Tests.Model_UTs.Games
+{
+    public class MasterOfCeremoniesTest
+    {
+        private readonly MasterOfCeremonies stubMasterOfCeremonies = new Stub().LoadApp();
+
+        [Fact]
+        public void TestPlayGameWhenPlayThenAddNewTurnToHistory()
+        {
+            // Arrange
+            MasterOfCeremonies masterOfCeremonies = stubMasterOfCeremonies;
+            Game game = masterOfCeremonies.GameManager.GetAll().First();
+
+            // Act
+            int turnsBefore = game.GetHistory().Count();
+            MasterOfCeremonies.PlayGame(game);
+            int turnsAfter = game.GetHistory().Count();
+
+            // Assert
+            Assert.Equal(turnsBefore + 1, turnsAfter);
+        }
+
+        [Fact]
+        public void TestStartNewGame()
+        {
+            // Arrange
+            MasterOfCeremonies masterOfCeremonies = stubMasterOfCeremonies;
+            string name = "blargh";
+
+            // Act
+            Assert.DoesNotContain(masterOfCeremonies.GameManager.GetOneByName(name), masterOfCeremonies.GameManager.GetAll());
+            masterOfCeremonies.StartNewGame(name, new PlayerManager(), stubMasterOfCeremonies.GameManager.GetAll().First().Dice);
+
+            // Assert
+            Assert.Contains(masterOfCeremonies.GameManager.GetOneByName(name), masterOfCeremonies.GameManager.GetAll());
+        }
+    }
+}

Sources/Tests/Model_UTs/Games/TurnTest.cs

@@ -13,14 +13,14 @@ namespace Tests.Model_UTs.Games
     public class TurnTest
 
     {
-        private readonly GameRunner stubGameRunner = new Stub().LoadApp();
+        private readonly MasterOfCeremonies stubMasterOfCeremonies = new Stub().LoadApp();
 
         Dictionary<Die, Face> DICE_N_FACES_1, DICE_N_FACES_2;
 
         public TurnTest()
         {
-            DICE_N_FACES_1 = (Dictionary<Die, Face>)stubGameRunner.GetAll().First().GetHistory().First().DiceNFaces;
+            DICE_N_FACES_1 = (Dictionary<Die, Face>)stubMasterOfCeremonies.GameManager.GetAll().First().GetHistory().First().DiceNFaces;
-            DICE_N_FACES_2 = (Dictionary<Die, Face>)stubGameRunner.GetAll().Last().GetHistory().Last().DiceNFaces;
+            DICE_N_FACES_2 = (Dictionary<Die, Face>)stubMasterOfCeremonies.GameManager.GetAll().Last().GetHistory().Last().DiceNFaces;
         }
 
         [Fact]