alexis.drai
/
dice_app
0
0
Fork 0
Code Issues 60 Pull Requests Packages Projects 1 Releases Wiki Activity

🚚 Organize UTs in folders
continuous-integration/drone/push Build is passing Details

Browse Source
pull/104/head
Alexis Drai 3 years ago
parent ca6b62574e
commit b8ea8a020e
7 changed files with 637 additions and 636 deletions
Show Stats Download Patch File Download Diff File

5
Sources/Tests/Model_UTs/PlayerEntityTest.cs → Sources/Tests/Data_UTs/Players/PlayerEntityTest.cs
Unescape View File

@ -6,8 +6,9 @@ using System.Text;
using System.Threading.Tasks; using System.Threading.Tasks;
using Xunit; using Xunit;
using Data.EF.Players; using Data.EF.Players;
using Tests.Model_UTs;
namespace Tests.Model_UTs namespace Tests.Data_UTs.Players
{ {
public class PlayerEntityTest public class PlayerEntityTest
{ {
@ -91,7 +92,7 @@ namespace Tests.Model_UTs
public void TestGoesThruToSecondMethodIfObjIsTypePlayerEntity() public void TestGoesThruToSecondMethodIfObjIsTypePlayerEntity()
{ {
// Arrange // Arrange
Object p1; object p1;
PlayerEntity p2; PlayerEntity p2;
// Act // Act

2
Sources/Tests/Model_UTs/PlayerExtensionsTest.cs → Sources/Tests/Data_UTs/Players/PlayerExtensionsTest.cs
Unescape View File

@ -7,7 +7,7 @@ using System.Text;
using System.Threading.Tasks; using System.Threading.Tasks;
using Xunit; using Xunit;
namespace Tests.Model_UTs namespace Tests.Data_UTs.Players
{ {
public class PlayerExtensionsTest public class PlayerExtensionsTest
{ {

614
Sources/Tests/Model_UTs/GameRunnerTest.cs → Sources/Tests/Model_UTs/Games/GameRunnerTest.cs
Unescape View File

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

2
Sources/Tests/Model_UTs/GameTest.cs → Sources/Tests/Model_UTs/Games/GameTest.cs
Unescape View File

@ -8,7 +8,7 @@ using System.Diagnostics;
using System.Linq; using System.Linq;
using Xunit; using Xunit;
namespace Tests.Model_UTs namespace Tests.Model_UTs.Games
{ {
public class GameTest public class GameTest
{ {

644
Sources/Tests/Model_UTs/TurnTest.cs → Sources/Tests/Model_UTs/Games/TurnTest.cs
Unescape View File

@ -1,322 +1,322 @@
using Model.Dice; using Model.Dice;
using Model.Dice.Faces; using Model.Dice.Faces;
using Model.Games; using Model.Games;
using Model.Players; using Model.Players;
using System; using System;
using System.Collections.Generic; using System.Collections.Generic;
using System.Diagnostics; using System.Diagnostics;
using System.Linq; using System.Linq;
using Xunit; using Xunit;
namespace Tests.Model_UTs namespace Tests.Model_UTs.Games
{ {
public class TurnTest public class TurnTest
{ {
private readonly Dictionary<AbstractDie<AbstractDieFace>, AbstractDieFace> DICE_N_FACES_1; private readonly Dictionary<AbstractDie<AbstractDieFace>, AbstractDieFace> DICE_N_FACES_1;
private readonly Dictionary<AbstractDie<AbstractDieFace>, AbstractDieFace> DICE_N_FACES_2; private readonly Dictionary<AbstractDie<AbstractDieFace>, AbstractDieFace> DICE_N_FACES_2;
private static readonly AbstractDieFace FACE_ONE = new NumberDieFace(1); private static readonly AbstractDieFace FACE_ONE = new NumberDieFace(1);
private static readonly AbstractDieFace FACE_TWO = new NumberDieFace(12); private static readonly AbstractDieFace FACE_TWO = new NumberDieFace(12);
private static readonly AbstractDieFace FACE_THREE = new ImageDieFace(54); private static readonly AbstractDieFace FACE_THREE = new ImageDieFace(54);
private static readonly AbstractDieFace FACE_FOUR = new ColorDieFace(16548); private static readonly AbstractDieFace FACE_FOUR = new ColorDieFace(16548);
private readonly static NumberDieFace[] FACES1 = new NumberDieFace[] private readonly static NumberDieFace[] FACES1 = new NumberDieFace[]
{ {
FACE_ONE as NumberDieFace, FACE_ONE as NumberDieFace,
new NumberDieFace(2), new NumberDieFace(2),
new NumberDieFace(3), new NumberDieFace(3),
new NumberDieFace(4) new NumberDieFace(4)
}; };
private readonly static NumberDieFace[] FACES2 = new NumberDieFace[] { private readonly static NumberDieFace[] FACES2 = new NumberDieFace[] {
new NumberDieFace(9), new NumberDieFace(9),
new NumberDieFace(10), new NumberDieFace(10),
new NumberDieFace(11), new NumberDieFace(11),
FACE_TWO as NumberDieFace, FACE_TWO as NumberDieFace,
new NumberDieFace(13), new NumberDieFace(13),
new NumberDieFace(14) new NumberDieFace(14)
}; };
private readonly static ImageDieFace[] FACES3 = new ImageDieFace[] { private readonly static ImageDieFace[] FACES3 = new ImageDieFace[] {
new ImageDieFace(13), new ImageDieFace(13),
new ImageDieFace(27), new ImageDieFace(27),
new ImageDieFace(38), new ImageDieFace(38),
FACE_THREE as ImageDieFace FACE_THREE as ImageDieFace
}; };
private readonly static ColorDieFace[] FACES4 = new ColorDieFace[] { private readonly static ColorDieFace[] FACES4 = new ColorDieFace[] {
new(11651), new(11651),
new(24651), new(24651),
FACE_FOUR as ColorDieFace, FACE_FOUR as ColorDieFace,
new(412) new(412)
}; };
private readonly AbstractDie<AbstractDieFace> NUM1 = new NumberDie(FACES1); private readonly AbstractDie<AbstractDieFace> NUM1 = new NumberDie(FACES1);
private readonly AbstractDie<AbstractDieFace> NUM2 = new NumberDie(FACES2); private readonly AbstractDie<AbstractDieFace> NUM2 = new NumberDie(FACES2);
private readonly AbstractDie<AbstractDieFace> IMG1 = new ImageDie(FACES3); private readonly AbstractDie<AbstractDieFace> IMG1 = new ImageDie(FACES3);
private readonly AbstractDie<AbstractDieFace> CLR1 = new ColorDie(FACES4); private readonly AbstractDie<AbstractDieFace> CLR1 = new ColorDie(FACES4);
public TurnTest() public TurnTest()
{ {
DICE_N_FACES_1 = new() DICE_N_FACES_1 = new()
{ {
{ NUM1, FACE_ONE }, { NUM1, FACE_ONE },
{ NUM2, FACE_TWO }, { NUM2, FACE_TWO },
{ IMG1, FACE_THREE }, { IMG1, FACE_THREE },
{ CLR1, FACE_FOUR } { CLR1, FACE_FOUR }
}; };
DICE_N_FACES_2 = new() DICE_N_FACES_2 = new()
{ {
{ NUM1, FACE_TWO }, { NUM1, FACE_TWO },
{ IMG1, FACE_THREE }, { IMG1, FACE_THREE },
{ CLR1, FACE_FOUR } { CLR1, FACE_FOUR }
}; };
} }
[Fact] [Fact]
public void TestCreateWithSpecifiedTimeNotUTCThenValid() public void TestCreateWithSpecifiedTimeNotUTCThenValid()
{ {
// Arrange // Arrange
DateTime dateTime = new(year: 2018, month: 06, day: 15, hour: 16, minute: 30, second: 0, kind: DateTimeKind.Local); DateTime dateTime = new(year: 2018, month: 06, day: 15, hour: 16, minute: 30, second: 0, kind: DateTimeKind.Local);
Player player = new("Alice"); Player player = new("Alice");
Assert.NotEqual(DateTimeKind.Utc, dateTime.Kind); Assert.NotEqual(DateTimeKind.Utc, dateTime.Kind);
// Act // Act
Turn turn = Turn.CreateWithSpecifiedTime(dateTime, player, DICE_N_FACES_1); Turn turn = Turn.CreateWithSpecifiedTime(dateTime, player, DICE_N_FACES_1);
// Assert // Assert
Assert.Equal(DateTimeKind.Utc, turn.When.Kind); Assert.Equal(DateTimeKind.Utc, turn.When.Kind);
Assert.Equal(dateTime.ToUniversalTime(), turn.When); Assert.Equal(dateTime.ToUniversalTime(), turn.When);
} }
[Fact] [Fact]
public void TestCreateWithSpecifiedTimeUTCThenValid() public void TestCreateWithSpecifiedTimeUTCThenValid()
{ {
// Arrange // Arrange
DateTime dateTime = new(year: 2018, month: 06, day: 15, hour: 16, minute: 30, second: 0, kind: DateTimeKind.Utc); DateTime dateTime = new(year: 2018, month: 06, day: 15, hour: 16, minute: 30, second: 0, kind: DateTimeKind.Utc);
Player player = new("Bobby"); Player player = new("Bobby");
Assert.Equal(DateTimeKind.Utc, dateTime.Kind); Assert.Equal(DateTimeKind.Utc, dateTime.Kind);
// Act // Act
Turn turn = Turn.CreateWithSpecifiedTime(dateTime, player, DICE_N_FACES_1); Turn turn = Turn.CreateWithSpecifiedTime(dateTime, player, DICE_N_FACES_1);
// Assert // Assert
Assert.Equal(DateTimeKind.Utc, turn.When.Kind); Assert.Equal(DateTimeKind.Utc, turn.When.Kind);
Assert.Equal(dateTime.ToUniversalTime(), turn.When); Assert.Equal(dateTime.ToUniversalTime(), turn.When);
} }
[Fact] [Fact]
public void TestCreateWithSpecifiedTimeNullPlayerThenException() public void TestCreateWithSpecifiedTimeNullPlayerThenException()
{ {
// Arrange // Arrange
DateTime dateTime = new(year: 2018, month: 06, day: 15, hour: 16, minute: 30, second: 0, kind: DateTimeKind.Utc); DateTime dateTime = new(year: 2018, month: 06, day: 15, hour: 16, minute: 30, second: 0, kind: DateTimeKind.Utc);
// Act // Act
void action() => Turn.CreateWithSpecifiedTime(dateTime, null, DICE_N_FACES_1); void action() => Turn.CreateWithSpecifiedTime(dateTime, null, DICE_N_FACES_1);
// Assert // Assert
Assert.Throws<ArgumentNullException>(action); Assert.Throws<ArgumentNullException>(action);
} }
[Fact] [Fact]
public void TestCreateWithSpecifiedTimeNullFacesThenException() public void TestCreateWithSpecifiedTimeNullFacesThenException()
{ {
// Arrange // Arrange
DateTime dateTime = new(year: 2018, month: 06, day: 15, hour: 16, minute: 30, second: 0, kind: DateTimeKind.Utc); DateTime dateTime = new(year: 2018, month: 06, day: 15, hour: 16, minute: 30, second: 0, kind: DateTimeKind.Utc);
Player player = new("Chucky"); Player player = new("Chucky");
// Act // Act
void action() => Turn.CreateWithSpecifiedTime(dateTime, player, null); void action() => Turn.CreateWithSpecifiedTime(dateTime, player, null);
// Assert // Assert
Assert.Throws<ArgumentNullException>(action); Assert.Throws<ArgumentNullException>(action);
} }
[Fact] [Fact]
public void TestCreateWithSpecifiedTimeEmptyFacesThenException() public void TestCreateWithSpecifiedTimeEmptyFacesThenException()
{ {
// Arrange // Arrange
DateTime dateTime = new(year: 2018, month: 06, day: 15, hour: 16, minute: 30, second: 0, kind: DateTimeKind.Utc); DateTime dateTime = new(year: 2018, month: 06, day: 15, hour: 16, minute: 30, second: 0, kind: DateTimeKind.Utc);
Player player = new("Chucky"); Player player = new("Chucky");
DICE_N_FACES_1.Clear(); DICE_N_FACES_1.Clear();
// Act // Act
void action() => Turn.CreateWithSpecifiedTime(dateTime, player, DICE_N_FACES_1); void action() => Turn.CreateWithSpecifiedTime(dateTime, player, DICE_N_FACES_1);
// Assert // Assert
Assert.Throws<ArgumentException>(action); Assert.Throws<ArgumentException>(action);
} }
[Fact] [Fact]
public void TestCreateWithDefaultTimeThenValid() public void TestCreateWithDefaultTimeThenValid()
{ {
// Arrange // Arrange
Player player = new("Chloe"); Player player = new("Chloe");
// Act // Act
Turn turn = Turn.CreateWithDefaultTime(player, DICE_N_FACES_1); Turn turn = Turn.CreateWithDefaultTime(player, DICE_N_FACES_1);
// Assert // Assert
Assert.Equal(DateTimeKind.Utc, turn.When.Kind); Assert.Equal(DateTimeKind.Utc, turn.When.Kind);
Assert.Equal(DateTime.Now.ToUniversalTime().Date, turn.When.Date); Assert.Equal(DateTime.Now.ToUniversalTime().Date, turn.When.Date);
// N.B.: might fail between 11:59:59PM and 00:00:00AM // N.B.: might fail between 11:59:59PM and 00:00:00AM
} }
[Fact] [Fact]
public void TestToStringValidIfAllNormal() public void TestToStringValidIfAllNormal()
{ {
// Arrange // Arrange
DateTime dateTime = new(year: 2018, month: 06, day: 15, hour: 16, minute: 30, second: 0, kind: DateTimeKind.Utc); DateTime dateTime = new(year: 2018, month: 06, day: 15, hour: 16, minute: 30, second: 0, kind: DateTimeKind.Utc);
string name = "Bobby"; string name = "Bobby";
Player player = new(name); Player player = new(name);
string expected = $"2018-06-15 16:30:00 -- {name} rolled: " string expected = $"2018-06-15 16:30:00 -- {name} rolled: "
+ FACE_ONE.ToString() + " " + FACE_ONE.ToString() + " "
+ FACE_TWO.ToString() + " " + FACE_TWO.ToString() + " "
+ FACE_THREE.ToString() + " " + FACE_THREE.ToString() + " "
+ FACE_FOUR.ToString(); + FACE_FOUR.ToString();
Turn turn = Turn.CreateWithSpecifiedTime(dateTime, player, DICE_N_FACES_1); Turn turn = Turn.CreateWithSpecifiedTime(dateTime, player, DICE_N_FACES_1);
// Act // Act
string actual = turn.ToString(); string actual = turn.ToString();
Debug.WriteLine(actual); Debug.WriteLine(actual);
// Assert // Assert
Assert.Equal(expected, actual); Assert.Equal(expected, actual);
} }
[Fact] [Fact]
public void TestDiceNFacesProperty() public void TestDiceNFacesProperty()
{ {
// Arrange // Arrange
Player player = new("Erika"); Player player = new("Erika");
// Act // Act
Turn turn = Turn.CreateWithDefaultTime(player, DICE_N_FACES_1); Turn turn = Turn.CreateWithDefaultTime(player, DICE_N_FACES_1);
IEnumerable<KeyValuePair<AbstractDie<AbstractDieFace>, AbstractDieFace>> expected = DICE_N_FACES_1.AsEnumerable(); IEnumerable<KeyValuePair<AbstractDie<AbstractDieFace>, AbstractDieFace>> expected = DICE_N_FACES_1.AsEnumerable();
// Assert // Assert
Assert.Equal(expected, turn.DiceNFaces); Assert.Equal(expected, turn.DiceNFaces);
} }
[Fact] [Fact]
public void TestEqualsFalseIfNotTurn() public void TestEqualsFalseIfNotTurn()
{ {
// Arrange // Arrange
Point point; Point point;
Turn turn; Turn turn;
Player player = new("Freddie"); Player player = new("Freddie");
// Act // Act
point = new(1, 2); point = new(1, 2);
turn = Turn.CreateWithDefaultTime(player, DICE_N_FACES_1); turn = Turn.CreateWithDefaultTime(player, DICE_N_FACES_1);
// Assert // Assert
Assert.False(point.Equals(turn)); Assert.False(point.Equals(turn));
Assert.False(point.GetHashCode().Equals(turn.GetHashCode())); Assert.False(point.GetHashCode().Equals(turn.GetHashCode()));
Assert.False(turn.Equals(point)); Assert.False(turn.Equals(point));
Assert.False(turn.GetHashCode().Equals(point.GetHashCode())); Assert.False(turn.GetHashCode().Equals(point.GetHashCode()));
} }
[Fact] [Fact]
public void TestGoesThruToSecondMethodIfObjIsTypeTurn() public void TestGoesThruToSecondMethodIfObjIsTypeTurn()
{ {
// Arrange // Arrange
Object t1; object t1;
Turn t2; Turn t2;
Player player1 = new Player("Marvin"); Player player1 = new Player("Marvin");
Player player2 = new Player("Noah"); Player player2 = new Player("Noah");
// Act // Act
t1 = Turn.CreateWithDefaultTime(player1, DICE_N_FACES_1); t1 = Turn.CreateWithDefaultTime(player1, DICE_N_FACES_1);
t2 = Turn.CreateWithDefaultTime(player2, DICE_N_FACES_2); t2 = Turn.CreateWithDefaultTime(player2, DICE_N_FACES_2);
// Assert // Assert
Assert.False(t1.Equals(t2)); Assert.False(t1.Equals(t2));
Assert.False(t1.GetHashCode().Equals(t2.GetHashCode())); Assert.False(t1.GetHashCode().Equals(t2.GetHashCode()));
Assert.False(t2.Equals(t1)); Assert.False(t2.Equals(t1));
Assert.False(t2.GetHashCode().Equals(t1.GetHashCode())); Assert.False(t2.GetHashCode().Equals(t1.GetHashCode()));
} }
[Fact] [Fact]
public void TestEqualsFalseIfNotSamePlayer() public void TestEqualsFalseIfNotSamePlayer()
{ {
// Arrange // Arrange
Player player1= new("Panama"); Player player1 = new("Panama");
Player player2= new("Clyde"); Player player2 = new("Clyde");
// Act // Act
Turn t1 = Turn.CreateWithDefaultTime(player1, DICE_N_FACES_2); Turn t1 = Turn.CreateWithDefaultTime(player1, DICE_N_FACES_2);
Turn t2 = Turn.CreateWithDefaultTime(player2, DICE_N_FACES_2); Turn t2 = Turn.CreateWithDefaultTime(player2, DICE_N_FACES_2);
// Assert // Assert
Assert.False(t1.Equals(t2)); Assert.False(t1.Equals(t2));
Assert.False(t1.GetHashCode().Equals(t2.GetHashCode())); Assert.False(t1.GetHashCode().Equals(t2.GetHashCode()));
Assert.False(t2.Equals(t1)); Assert.False(t2.Equals(t1));
Assert.False(t2.GetHashCode().Equals(t1.GetHashCode())); Assert.False(t2.GetHashCode().Equals(t1.GetHashCode()));
} }
[Fact] [Fact]
public void TestEqualsFalseIfNotSameTime() public void TestEqualsFalseIfNotSameTime()
{ {
// Arrange // Arrange
Player player = new("Oscar"); Player player = new("Oscar");
// Act // Act
Turn t1 = Turn.CreateWithSpecifiedTime(new DateTime(1994, 07, 10), player, DICE_N_FACES_1); Turn t1 = Turn.CreateWithSpecifiedTime(new DateTime(1994, 07, 10), player, DICE_N_FACES_1);
Turn t2 = Turn.CreateWithSpecifiedTime(new DateTime(1991, 08, 20), player, DICE_N_FACES_1); Turn t2 = Turn.CreateWithSpecifiedTime(new DateTime(1991, 08, 20), player, DICE_N_FACES_1);
// Assert // Assert
Assert.False(t1.Equals(t2)); Assert.False(t1.Equals(t2));
Assert.False(t1.GetHashCode().Equals(t2.GetHashCode())); Assert.False(t1.GetHashCode().Equals(t2.GetHashCode()));
Assert.False(t2.Equals(t1)); Assert.False(t2.Equals(t1));
Assert.False(t2.GetHashCode().Equals(t1.GetHashCode())); Assert.False(t2.GetHashCode().Equals(t1.GetHashCode()));
} }
[Fact] [Fact]
public void TestEqualsFalseIfNotSameDiceNFaces() public void TestEqualsFalseIfNotSameDiceNFaces()
{ {
// Arrange // Arrange
Player player = new("Django"); Player player = new("Django");
// Act // Act
Turn t1 = Turn.CreateWithDefaultTime(player, DICE_N_FACES_1); Turn t1 = Turn.CreateWithDefaultTime(player, DICE_N_FACES_1);
Turn t2 = Turn.CreateWithDefaultTime(player, DICE_N_FACES_2); Turn t2 = Turn.CreateWithDefaultTime(player, DICE_N_FACES_2);
// Assert // Assert
Assert.False(t1.Equals(t2)); Assert.False(t1.Equals(t2));
Assert.False(t1.GetHashCode().Equals(t2.GetHashCode())); Assert.False(t1.GetHashCode().Equals(t2.GetHashCode()));
Assert.False(t2.Equals(t1)); Assert.False(t2.Equals(t1));
Assert.False(t2.GetHashCode().Equals(t1.GetHashCode())); Assert.False(t2.GetHashCode().Equals(t1.GetHashCode()));
} }
[Fact] [Fact]
public void TestEqualsTrueIfExactlySameProperties() public void TestEqualsTrueIfExactlySameProperties()
{ {
// Arrange // Arrange
Player player = new("Elyse"); Player player = new("Elyse");
// Act // Act
Turn t1 = Turn.CreateWithSpecifiedTime(new DateTime(1990, 04, 29), player, DICE_N_FACES_1); Turn t1 = Turn.CreateWithSpecifiedTime(new DateTime(1990, 04, 29), player, DICE_N_FACES_1);
Turn t2 = Turn.CreateWithSpecifiedTime(new DateTime(1990, 04, 29), player, DICE_N_FACES_1); Turn t2 = Turn.CreateWithSpecifiedTime(new DateTime(1990, 04, 29), player, DICE_N_FACES_1);
// Assert // Assert
Assert.True(t1.Equals(t2)); Assert.True(t1.Equals(t2));
Assert.True(t1.GetHashCode().Equals(t2.GetHashCode())); Assert.True(t1.GetHashCode().Equals(t2.GetHashCode()));
Assert.True(t2.Equals(t1)); Assert.True(t2.Equals(t1));
Assert.True(t2.GetHashCode().Equals(t1.GetHashCode())); Assert.True(t2.GetHashCode().Equals(t1.GetHashCode()));
} }
} }
} }

2
Sources/Tests/Model_UTs/PlayerManagerTest.cs → Sources/Tests/Model_UTs/Players/PlayerManagerTest.cs
Unescape View File

@ -5,7 +5,7 @@ using System.Collections.ObjectModel;
using System.Linq; using System.Linq;
using Xunit; using Xunit;
namespace Tests.Model_UTs namespace Tests.Model_UTs.Players
{ {
public class PlayerManagerTest public class PlayerManagerTest
{ {

4
Sources/Tests/Model_UTs/PlayerTest.cs → Sources/Tests/Model_UTs/Players/PlayerTest.cs
Unescape View File

@ -2,7 +2,7 @@ using Model.Players;
using System; using System;
using Xunit; using Xunit;
namespace Tests.Model_UTs namespace Tests.Model_UTs.Players
{ {
public class PlayerTest public class PlayerTest
{ {
@ -99,7 +99,7 @@ namespace Tests.Model_UTs
public void TestGoesThruToSecondMethodIfObjIsTypePlayer() public void TestGoesThruToSecondMethodIfObjIsTypePlayer()
{ {
// Arrange // Arrange
Object p1; object p1;
Player p2; Player p2;
// Act // Act
Write Preview
Loading…
Cancel
Save