From 3c74fa496295fcab47df69001a436e84b4bc18d9 Mon Sep 17 00:00:00 2001 From: "alexis.drai" Date: Thu, 29 Sep 2022 09:43:47 +0200 Subject: [PATCH 1/4] :construction: WIP --- Sources/Model/Games/GameRunner.cs | 21 +- Sources/Tests/Model_UTs/GameRunnerTest.cs | 262 +++++++++++++++++++ Sources/Tests/Model_UTs/PlayerManagerTest.cs | 2 +- Sources/Tests/Tests.csproj | 1 + 4 files changed, 278 insertions(+), 8 deletions(-) create mode 100644 Sources/Tests/Model_UTs/GameRunnerTest.cs diff --git a/Sources/Model/Games/GameRunner.cs b/Sources/Model/Games/GameRunner.cs index 866bacb..e772ea0 100644 --- a/Sources/Model/Games/GameRunner.cs +++ b/Sources/Model/Games/GameRunner.cs @@ -22,6 +22,10 @@ namespace Model.Games this.games = games ?? new(); } + public GameRunner(IManager globalPlayerManager, IManager>>> globalDieManager) + : this(globalPlayerManager, globalDieManager, null){ } + + public IEnumerable GetAll() => games.AsEnumerable(); /// @@ -44,18 +48,21 @@ namespace Model.Games /// /// saves a given game -- does not allow copies yet: if a game with the same name exists, it is overwritten /// - /// a game to save + /// a game to save /// - public Game Add(Game game) + public Game Add(Game toAdd) { - if (game != null) + if (toAdd is null) + { + throw new ArgumentNullException(nameof(toAdd), "param should not be null"); + } + else { - games.Remove(games.FirstOrDefault(g => g.Name == game.Name)); + games.Remove(games.FirstOrDefault(g => g.Name == toAdd.Name)); // will often be an update: if game with that name exists, it is removed, else, nothing happens above - games.Add(game); - return game; + games.Add(toAdd); + return toAdd; } - return null; } /// diff --git a/Sources/Tests/Model_UTs/GameRunnerTest.cs b/Sources/Tests/Model_UTs/GameRunnerTest.cs new file mode 100644 index 0000000..b35f774 --- /dev/null +++ b/Sources/Tests/Model_UTs/GameRunnerTest.cs @@ -0,0 +1,262 @@ +using Model.Games; +using Model.Dice; +using Model.Dice.Faces; +using Model.Players; +using Data; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; +using Xunit; + +namespace Tests.Model_UTs +{ + public class GameRunnerTest + { + private readonly GameRunner stubGameRunner; + public GameRunnerTest() + { + stubGameRunner = new Stub().LoadApp(); + } + + [Fact] + public void TestConstructorWhenNoGamesThenNewIEnumerable() + { + // Arrange + GameRunner gameRunner = new(new PlayerManager(), new DieManager()); + IEnumerable expected; + IEnumerable actual; + + // Act + expected = new List().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 expected; + IEnumerable 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 expected = new List() { game1, game2 }.AsEnumerable(); + IEnumerable actual = new List() + { + gameRunner.Add(game1), + gameRunner.Add(game2) + }; + + // Assert + Assert.Equal(expected, actual); + } + + [Fact] + public void TestAddwhenNullThenThrowsException() + { + // Arrange + + + // Act + void action() => stubGameRunner.Add(null);// Add() returns the added element if succesful + + // Assert + Assert.Throws(action); + Assert.DoesNotContain(null, stubGameRunner.GetAll()); + } + + [Theory] + [InlineData("")] + [InlineData(null)] + [InlineData(" ")] + public void TestGetOneByNameIfInvalidThrowsException(string name) + { + // Arrange + + + // Act + void action() => stubGameRunner.GetOneByName(name); + + // Assert + Assert.Throws(action); + } + + [Fact] + public void TestGetOneByNameIfValidButNotExistThenReturnNull() + { + // Arrange + + + // Act + Game result = stubGameRunner.GetOneByName("thereisbasicalllynowaythatthisgamenamealreadyexists"); + + // Assert + Assert.Null(result); + } + + [Theory] + [InlineData("Bob")] + [InlineData("bob")] + [InlineData("bob ")] + [InlineData(" boB ")] + public void TestGetOneByNameIfValidThenReturnPlayer(string name) + { + // Arrange + + + // Act + + + // Assert + + } + + [Fact] + public void TestRemoveWorksIfExists() + { + // Arrange + + + // Act + + + // Assert + + } + + [Fact] + public void TestRemoveThrowsExceptionIfGivenNull() + { + // Arrange + + + // Act + + + // Assert + + } + + [Fact] + public void TestRemoveFailsSilentlyIfGivenNonExistent() + { + // Arrange + + + // Act + + + // Assert + + } + + [Fact] + public void TestUpdateWorksIfValid() + { + // Arrange + + + // Act + + + // Assert + + } + + [Theory] + [InlineData("Filibert", "filibert")] + [InlineData("Filibert", " fiLibert")] + [InlineData("Filibert", "FIlibert ")] + [InlineData(" Filibert", " filiBErt ")] + public void TestUpdateDiscreetlyUpdatesCaseAndIgnoresExtraSpaceIfOtherwiseSame(string n1, string n2) + { + // Arrange + + + // Act + + + // Assert + + } + + [Theory] + [InlineData("")] + [InlineData(" ")] + [InlineData(null)] + public void TestUpdateDoesNotGoWithValidBeforeAndInvalidAfter(string badName) + { + // Arrange + + + // Act + + + // Assert + + } + + [Fact] + public void TestUpdateDoesNotGoWithValidBeforeAndNullAfter() + { + // Arrange + + + // Act + + + // Assert + + } + + [Fact] + public void TestUpdateDoesNotGoWithValidAfterAndNullBefore() + { + // Arrange + + + // Act + + + // Assert + + } + + [Theory] + [InlineData("")] + [InlineData(" ")] + [InlineData(null)] + public void TestUpdateDoesNotGoWithValidAfterAndInvalidBefore(string name) + { + // Arrange + + + // Act + + + // Assert + + } + } +} diff --git a/Sources/Tests/Model_UTs/PlayerManagerTest.cs b/Sources/Tests/Model_UTs/PlayerManagerTest.cs index c698a95..fe94980 100644 --- a/Sources/Tests/Model_UTs/PlayerManagerTest.cs +++ b/Sources/Tests/Model_UTs/PlayerManagerTest.cs @@ -59,8 +59,8 @@ namespace Tests.Model_UTs // Assert Assert.Null(expected); - Assert.DoesNotContain(expected, playerManager.GetAll()); Assert.Throws(action); + Assert.DoesNotContain(expected, playerManager.GetAll()); } [Fact] diff --git a/Sources/Tests/Tests.csproj b/Sources/Tests/Tests.csproj index c899ea9..2d2506b 100644 --- a/Sources/Tests/Tests.csproj +++ b/Sources/Tests/Tests.csproj @@ -20,6 +20,7 @@ + -- 2.36.3 From 062c17b7f137ec811fc1bd7b37f1f55e984e2c61 Mon Sep 17 00:00:00 2001 From: "alexis.drai" Date: Thu, 29 Sep 2022 09:48:16 +0200 Subject: [PATCH 2/4] :construction: WIP --- Sources/Tests/Model_UTs/GameRunnerTest.cs | 18 ++++++++---------- 1 file changed, 8 insertions(+), 10 deletions(-) diff --git a/Sources/Tests/Model_UTs/GameRunnerTest.cs b/Sources/Tests/Model_UTs/GameRunnerTest.cs index b35f774..9bf6f20 100644 --- a/Sources/Tests/Model_UTs/GameRunnerTest.cs +++ b/Sources/Tests/Model_UTs/GameRunnerTest.cs @@ -109,27 +109,25 @@ namespace Tests.Model_UTs // Act - Game result = stubGameRunner.GetOneByName("thereisbasicalllynowaythatthisgamenamealreadyexists"); + Game result = stubGameRunner.GetOneByName("thereisbasicallynowaythatthisgamenamealreadyexists"); // Assert Assert.Null(result); } - [Theory] - [InlineData("Bob")] - [InlineData("bob")] - [InlineData("bob ")] - [InlineData(" boB ")] - public void TestGetOneByNameIfValidThenReturnPlayer(string name) + [Fact] + public void TestGetOneByNameIfValidThenReturnGame() { // 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] -- 2.36.3 From 8d8c2f445a6e00341997b84cd2ed5bf76dd947d1 Mon Sep 17 00:00:00 2001 From: "alexis.drai" Date: Thu, 29 Sep 2022 10:11:10 +0200 Subject: [PATCH 3/4] :poop: --- Sources/Tests/Model_UTs/GameRunnerTest.cs | 50 ++++++++--------------- 1 file changed, 18 insertions(+), 32 deletions(-) diff --git a/Sources/Tests/Model_UTs/GameRunnerTest.cs b/Sources/Tests/Model_UTs/GameRunnerTest.cs index 9bf6f20..6bf4626 100644 --- a/Sources/Tests/Model_UTs/GameRunnerTest.cs +++ b/Sources/Tests/Model_UTs/GameRunnerTest.cs @@ -73,7 +73,7 @@ namespace Tests.Model_UTs } [Fact] - public void TestAddwhenNullThenThrowsException() + public void TestAddWhenNullThenThrowsException() { // Arrange @@ -90,7 +90,7 @@ namespace Tests.Model_UTs [InlineData("")] [InlineData(null)] [InlineData(" ")] - public void TestGetOneByNameIfInvalidThrowsException(string name) + public void TestGetOneByNameWhenInvalidThenThrowsException(string name) { // Arrange @@ -103,7 +103,7 @@ namespace Tests.Model_UTs } [Fact] - public void TestGetOneByNameIfValidButNotExistThenReturnNull() + public void TestGetOneByNameWhenValidButNotExistThenReturnNull() { // Arrange @@ -116,7 +116,7 @@ namespace Tests.Model_UTs } [Fact] - public void TestGetOneByNameIfValidThenReturnGame() + public void TestGetOneByNameWhenValidThenReturnGame() { // Arrange GameRunner gameRunner = new(new PlayerManager(), new DieManager()); @@ -131,42 +131,45 @@ namespace Tests.Model_UTs } [Fact] - public void TestRemoveWorksIfExists() + public void TestWhenRemoveExistsThenSucceeds() { // Arrange - + Game game = new("blargh", new PlayerManager(), stubGameRunner.GetAll().First().Dice); + stubGameRunner.Add(game); // Act - + stubGameRunner.Remove(game); // Assert - + Assert.DoesNotContain(game, stubGameRunner.GetAll()); } [Fact] - public void TestRemoveThrowsExceptionIfGivenNull() + public void TestRemoveWhenGivenNullThenThrowsException() { // Arrange // Act - + void action() => stubGameRunner.Remove(null); // Assert - + Assert.Throws(action); } [Fact] - public void TestRemoveFailsSilentlyIfGivenNonExistent() + public void TestRemoveWhenGiveenNonExistentThenFailsSilently() { // Arrange - + Game notGame = new("blargh", new PlayerManager(), stubGameRunner.GetAll().First().Dice); + IEnumerable expected = stubGameRunner.GetAll(); // Act - + stubGameRunner.Remove(notGame); + IEnumerable actual = stubGameRunner.GetAll(); // Assert - + Assert.Equal(actual, expected); } [Fact] @@ -182,23 +185,6 @@ namespace Tests.Model_UTs } - [Theory] - [InlineData("Filibert", "filibert")] - [InlineData("Filibert", " fiLibert")] - [InlineData("Filibert", "FIlibert ")] - [InlineData(" Filibert", " filiBErt ")] - public void TestUpdateDiscreetlyUpdatesCaseAndIgnoresExtraSpaceIfOtherwiseSame(string n1, string n2) - { - // Arrange - - - // Act - - - // Assert - - } - [Theory] [InlineData("")] [InlineData(" ")] -- 2.36.3 From 455f1210ef9cf2813d446b21faed3110e09796ef Mon Sep 17 00:00:00 2001 From: "alexis.drai" Date: Thu, 29 Sep 2022 10:47:49 +0200 Subject: [PATCH 4/4] :white_check_mark: Complete test suite, add checks to R and U --- Sources/Model/Games/GameRunner.cs | 37 +++++++++---- Sources/Tests/Model_UTs/GameRunnerTest.cs | 65 ++++++++++++++++------- 2 files changed, 73 insertions(+), 29 deletions(-) diff --git a/Sources/Model/Games/GameRunner.cs b/Sources/Model/Games/GameRunner.cs index e772ea0..15391f7 100644 --- a/Sources/Model/Games/GameRunner.cs +++ b/Sources/Model/Games/GameRunner.cs @@ -56,13 +56,11 @@ namespace Model.Games { throw new ArgumentNullException(nameof(toAdd), "param should not be null"); } - else - { - games.Remove(games.FirstOrDefault(g => g.Name == toAdd.Name)); - // will often be an update: if game with that name exists, it is removed, else, nothing happens above - games.Add(toAdd); - return toAdd; - } + + games.Remove(games.FirstOrDefault(g => g.Name == toAdd.Name)); + // will often be an update: if game with that name exists, it is removed, else, nothing happens above + games.Add(toAdd); + return toAdd; } /// @@ -75,14 +73,31 @@ namespace Model.Games Add(game); } - public void Remove(Game game) + public void Remove(Game toRemove) { - games.Remove(game); + if (toRemove is null) + { + throw new ArgumentNullException(nameof(toRemove), "param should not be null"); + } + games.Remove(toRemove); } - public Game Update(Game oldGame, Game newGame) + public Game Update(Game before, Game after) { - return Add(newGame); + + Game[] args = { before, after }; + + foreach (Game game in args) + { + if (game is null) + { + throw new ArgumentNullException(nameof(after), "param should not be null"); + // could also be because of before, but one param had to be chosen as an example + // and putting "player" there was raising a major code smell + } + } + Remove(before); + return Add(after); } /// diff --git a/Sources/Tests/Model_UTs/GameRunnerTest.cs b/Sources/Tests/Model_UTs/GameRunnerTest.cs index 6bf4626..c8a715b 100644 --- a/Sources/Tests/Model_UTs/GameRunnerTest.cs +++ b/Sources/Tests/Model_UTs/GameRunnerTest.cs @@ -173,74 +173,103 @@ namespace Tests.Model_UTs } [Fact] - public void TestUpdateWorksIfValid() + 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 TestUpdateDoesNotGoWithValidBeforeAndInvalidAfter(string badName) + public void TestUpdateWhenValidBeforeAndInvalidAfterThenDoesNotGo(string badName) { // Arrange - + int expectedSize = stubGameRunner.GetAll().Count(); + Game oldGame = stubGameRunner.GetAll().First(); // Act - + void action() => stubGameRunner.Update(oldGame, new(badName, oldGame.PlayerManager, oldGame.Dice)); + int actualSize = stubGameRunner.GetAll().Count(); // Assert - + Assert.Throws(action); // thrown by constructor + Assert.Contains(oldGame, stubGameRunner.GetAll()); // still there + Assert.True(expectedSize == actualSize); } [Fact] - public void TestUpdateDoesNotGoWithValidBeforeAndNullAfter() + public void TestUpdateWhenValidBeforeAndNullAfterThenDoesNotGo() { // Arrange - + int expectedSize = stubGameRunner.GetAll().Count(); + Game oldGame = stubGameRunner.GetAll().First(); // Act - + void action() => stubGameRunner.Update(oldGame, null); + int actualSize = stubGameRunner.GetAll().Count(); // Assert - + Assert.Throws(action); // thrown by constructor + Assert.Contains(oldGame, stubGameRunner.GetAll()); // still there + Assert.True(expectedSize == actualSize); } [Fact] public void TestUpdateDoesNotGoWithValidAfterAndNullBefore() { // Arrange - + int expectedSize = stubGameRunner.GetAll().Count(); + Game oldGame = stubGameRunner.GetAll().First(); // Act - + void action() => stubGameRunner.Update(null, new("newgamename", oldGame.PlayerManager, oldGame.Dice)); + int actualSize = stubGameRunner.GetAll().Count(); // Assert - + Assert.Throws(action); // thrown by constructor + Assert.Contains(oldGame, stubGameRunner.GetAll()); // still there + Assert.True(expectedSize == actualSize); } [Theory] [InlineData("")] [InlineData(" ")] [InlineData(null)] - public void TestUpdateDoesNotGoWithValidAfterAndInvalidBefore(string name) + public void TestUpdateWhenInvalidBeforeAndValidAfterThenDoesNotGo(string badName) { // Arrange - + int expectedSize = stubGameRunner.GetAll().Count(); + Game oldGame = stubGameRunner.GetAll().First(); // Act - + void action() => stubGameRunner.Update(new(badName, oldGame.PlayerManager, oldGame.Dice), new("valid", oldGame.PlayerManager, oldGame.Dice)); + int actualSize = stubGameRunner.GetAll().Count(); // Assert - + Assert.Throws(action); // thrown by constructor + Assert.Contains(oldGame, stubGameRunner.GetAll()); // still there + Assert.True(expectedSize == actualSize); } } } -- 2.36.3