public void RunTestMissingConfig() { var loggerDouble = new LoggerDouble <App>(); var mockConfig = new Mock <IConfiguration>(); var mockGameplayCoordinator = new Mock <ICoordinateGameplay>(); var statsGathererMock = new Mock <IFinalizeStats>(); var dummySimulationStats = new Mock <ISimulationStats>(); var configurationSection = new Mock <IConfigurationSection>(); mockConfig.Setup(a => a.GetSection(It.IsAny <string>())).Returns(configurationSection.Object); mockGameplayCoordinator.Setup(mock => mock.Play(It.IsAny <GameParameters>())).Returns(dummySimulationStats.Object); var objectUnderTest = new App(mockConfig.Object, loggerDouble, mockGameplayCoordinator.Object, statsGathererMock.Object); objectUnderTest.Run(); mockGameplayCoordinator.Verify(mock => mock.Play( It.Is <GameParameters>( item => item.FirstPlayerName == "Player 1" && item.SecondPlayerName == "Player 2" && item.TotalLengthOfSimulation == TimeSpan.FromMinutes(60 * 24) )), Times.Once()); statsGathererMock.Verify(mock => mock.GetFinalStats(It.IsAny <GameParameters>(), dummySimulationStats.Object), Times.Once()); }
public void TransitionTestShufflingTakesTimeAndCanTimeOutGame() { var loggerDouble = new LoggerDouble <PlayWar>(); var firstPlayerState = new PlayerGameState { GatherPile = new CardPile { Cards = new List <Card> { new Card { Rank = "K", Suit = Constants.Suits.Hearts } } }, PlayPile = new CardPile { Cards = new List <Card> { } }, PlayedCards = new CardPile { Cards = new List <Card> { } } }; var secondPlayerState = new PlayerGameState { GatherPile = new CardPile { Cards = new List <Card> { new Card { Rank = "3", Suit = Constants.Suits.Clubs } } }, PlayPile = new CardPile { Cards = new List <Card> { } }, PlayedCards = new CardPile { Cards = new List <Card> { } } }; var gameStateMock = new Mock <ITrackIndividualGameState>(); gameStateMock.Setup(mock => mock.FirstPlayerState).Returns(firstPlayerState); gameStateMock.Setup(mock => mock.SecondPlayerState).Returns(secondPlayerState); var maxDuration = TimeSpan.FromMinutes(5); gameStateMock.Setup(mock => mock.MaxDuration).Returns(maxDuration); var timeElapsedInGame = new TimeSpan(hours: 0, minutes: 4, seconds: 59); gameStateMock.Setup(mock => mock.TimeElapsed).Returns(() => timeElapsedInGame); gameStateMock.Setup(mock => mock.Tick(It.IsAny <TimeSpan>())) .Callback <TimeSpan>((timeTaken) => timeElapsedInGame += timeTaken); gameStateMock.Setup(mock => mock.TimedOut).Returns(() => timeElapsedInGame > maxDuration); var objectUnderTest = new PlayWar(loggerDouble); //ensure we haven't timed out yet and the simulation will make us time out Assert.True(gameStateMock.Object.TimedOut == false); objectUnderTest.Transition(gameStateMock.Object); gameStateMock.Verify(mock => mock.Tick(Constants.GamePlayParameters.TimeToShuffle), Times.Once()); Assert.True(loggerDouble.TraceEntries.Count() == 6); Assert.True(loggerDouble.HasBeenLogged(LogLevel.Trace, "After transition, player 1 has 1 card(s) in their play pile")); Assert.True(loggerDouble.HasBeenLogged(LogLevel.Trace, "After transition, player 1 has 0 card(s) in their gather pile")); Assert.True(loggerDouble.HasBeenLogged(LogLevel.Trace, "After transition, player 1 has 0 card(s) in their played cards pile")); Assert.True(loggerDouble.HasBeenLogged(LogLevel.Trace, "After transition, player 2 has 1 card(s) in their play pile")); Assert.True(loggerDouble.HasBeenLogged(LogLevel.Trace, "After transition, player 2 has 0 card(s) in their gather pile")); Assert.True(loggerDouble.HasBeenLogged(LogLevel.Trace, "After transition, player 2 has 0 card(s) in their played cards pile")); Assert.True(loggerDouble.DebugEntries.Count() == 4); Assert.True(loggerDouble.HasBeenLogged(LogLevel.Debug, "Moving 1 card(s) from gather pile to play pile for player 1...")); Assert.True(loggerDouble.HasBeenLogged(LogLevel.Debug, "Moving 1 card(s) from gather pile to play pile for player 2...")); Assert.True(loggerDouble.HasBeenLogged(LogLevel.Debug, "Total time taken so far is 314 seconds")); Assert.True(loggerDouble.HasBeenLogged(LogLevel.Debug, "Game over after 314 seconds because max mins is 5")); }
public void WarTestAlmostImpossibleCase() { var loggerDouble = new LoggerDouble <PlayWar>(); var firstPlayerState = new PlayerGameState { PlayPile = new CardPile { Cards = new List <Card> { new Card { Rank = "A", Suit = Constants.Suits.Clubs }, new Card { Rank = "K", Suit = Constants.Suits.Diamonds }, new Card { Rank = "K", Suit = Constants.Suits.Hearts }, new Card { Rank = "K", Suit = Constants.Suits.Clubs }, } }, GatherPile = new CardPile { Cards = new List <Card> { new Card { Rank = "A", Suit = Constants.Suits.Diamonds }, } }, PlayedCards = new CardPile { Cards = new List <Card> { } } }; var secondPlayerState = new PlayerGameState { PlayPile = new CardPile { Cards = new List <Card> { new Card { Rank = "A", Suit = Constants.Suits.Spades }, new Card { Rank = "Q", Suit = Constants.Suits.Diamonds }, new Card { Rank = "Q", Suit = Constants.Suits.Hearts }, new Card { Rank = "Q", Suit = Constants.Suits.Clubs }, } }, GatherPile = new CardPile { Cards = new List <Card> { new Card { Rank = "A", Suit = Constants.Suits.Hearts }, } }, PlayedCards = new CardPile { Cards = new List <Card> { } } }; var gameStateMock = new Mock <ITrackIndividualGameState>(); gameStateMock.Setup(mock => mock.FirstPlayerState).Returns(firstPlayerState); gameStateMock.Setup(mock => mock.SecondPlayerState).Returns(secondPlayerState); var objectUnderTest = new PlayWar(loggerDouble); bool exceptionThrown = false; try { objectUnderTest.War(gameStateMock.Object, warDepth: 1); } catch { exceptionThrown = true; } Assert.True(exceptionThrown); }
public void WarTestNotEnoughCardsForWar(int winner) { var loggerDouble = new LoggerDouble <PlayWar>(); var extraCard = new Card { Rank = "K", Suit = Constants.Suits.Hearts }; var firstPlayerState = new PlayerGameState { PlayPile = new CardPile { Cards = new List <Card> { new Card { Rank = "5", Suit = Constants.Suits.Diamonds }, new Card { Rank = "A", Suit = Constants.Suits.Clubs }, new Card { Rank = "7", Suit = Constants.Suits.Spades }, new Card { Rank = "4", Suit = Constants.Suits.Diamonds } } }, GatherPile = new CardPile { Cards = new List <Card> { } }, PlayedCards = new CardPile { Cards = new List <Card> { } }, }; var secondPlayerState = new PlayerGameState { PlayPile = new CardPile { Cards = new List <Card> { new Card { Rank = "5", Suit = Constants.Suits.Hearts }, new Card { Rank = "2", Suit = Constants.Suits.Clubs }, new Card { Rank = "Q", Suit = Constants.Suits.Hearts }, new Card { Rank = "J", Suit = Constants.Suits.Diamonds } } }, GatherPile = new CardPile { Cards = new List <Card> { } }, PlayedCards = new CardPile { Cards = new List <Card> { } }, }; PlayerGameState winnerState; PlayerGameState loserState; if (winner == 1) { winnerState = firstPlayerState; loserState = secondPlayerState; } else { winnerState = secondPlayerState; loserState = firstPlayerState; } winnerState.GatherPile.Cards.Add(extraCard); var gameStateMock = new Mock <ITrackIndividualGameState>(); gameStateMock.Setup(mock => mock.FirstPlayerState).Returns(firstPlayerState); gameStateMock.Setup(mock => mock.SecondPlayerState).Returns(secondPlayerState); var objectUnderTest = new PlayWar(loggerDouble); Assert.True(firstPlayerState.CannotContinueBecauseCantPlayEnoughCardsForWar == false); Assert.True(secondPlayerState.CannotContinueBecauseCantPlayEnoughCardsForWar == false); objectUnderTest.War(gameStateMock.Object); Assert.True(winnerState.CannotContinueBecauseCantPlayEnoughCardsForWar == false); Assert.True(loserState.CannotContinueBecauseCantPlayEnoughCardsForWar == true); Assert.True(loggerDouble.HasBeenLogged(LogLevel.Debug, $"Player {(winner == 1 ? 2 : 1)} does not have enough cards for war...")); }
public void WarTestSimpleWarWhenBothNeedToShuffle() { var loggerDouble = new LoggerDouble <PlayWar>(); var singleGameStatsMock = new Mock <ISingleGameStats>(); var firstPlayerState = new PlayerGameState { PlayPile = new CardPile { Cards = new List <Card> { new Card { Rank = "5", Suit = Constants.Suits.Diamonds }, new Card { Rank = "A", Suit = Constants.Suits.Clubs }, } }, GatherPile = new CardPile { Cards = new List <Card> { new Card { Rank = "7", Suit = Constants.Suits.Spades }, new Card { Rank = "4", Suit = Constants.Suits.Diamonds }, new Card { Rank = "K", Suit = Constants.Suits.Hearts } } }, PlayedCards = new CardPile { Cards = new List <Card> { } }, }; // player 2 should always lose because he's always gonna play the 2 in the 2nd war var secondPlayerState = new PlayerGameState { PlayPile = new CardPile { Cards = new List <Card> { new Card { Rank = "5", Suit = Constants.Suits.Hearts }, new Card { Rank = "Q", Suit = Constants.Suits.Hearts }, new Card { Rank = "J", Suit = Constants.Suits.Diamonds }, new Card { Rank = "3", Suit = Constants.Suits.Clubs } } }, GatherPile = new CardPile { Cards = new List <Card> { new Card { Rank = "2", Suit = Constants.Suits.Clubs }, } }, PlayedCards = new CardPile { Cards = new List <Card> { } }, }; var gameStateMock = new Mock <ITrackIndividualGameState>(); gameStateMock.Setup(mock => mock.FirstPlayerState).Returns(firstPlayerState); gameStateMock.Setup(mock => mock.SecondPlayerState).Returns(secondPlayerState); var player1WarWinsByDepthTracker = new List <int>() { 0, 0, 0, 0, 0, 0, 0, 0 }; singleGameStatsMock.Setup(mock => mock.Player1WarWinsByDepth).Returns(player1WarWinsByDepthTracker); gameStateMock.Setup(mock => mock.Stats).Returns(singleGameStatsMock.Object); var objectUnderTest = new PlayWar(loggerDouble); objectUnderTest.War(gameStateMock.Object); gameStateMock.Verify(mock => mock.Tick(Constants.GamePlayParameters.TimeToPlayCard), Times.Exactly(2)); gameStateMock.Verify(mock => mock.Tick(Constants.GamePlayParameters.TimeToPlayCardsFaceDownForAWar), Times.Once()); gameStateMock.Verify(mock => mock.Tick(Constants.GamePlayParameters.TimeToShuffle), Times.Once()); gameStateMock.Verify(mock => mock.Tick(Constants.GamePlayParameters.TimeToGatherCards), Times.Once()); Assert.True(loggerDouble.HasBeenLogged(LogLevel.Debug, $"Player 1 wins")); Assert.True(player1WarWinsByDepthTracker[1] == 1); Assert.True(loggerDouble.HasBeenLogged(LogLevel.Debug, $"War: 5♦ vs 5♥...")); Assert.True(loggerDouble.HasBeenLogged(LogLevel.Debug, "War with depth 0 on this turn.")); Assert.True(loggerDouble.HasBeenLogged(LogLevel.Debug, "Moving 3 card(s) from gather pile to play pile for player 1...")); Assert.True(loggerDouble.HasBeenLogged(LogLevel.Debug, "Moving 1 card(s) from gather pile to play pile for player 2...")); Assert.True(loggerDouble.DebugEntries.Count() == 14); Assert.True(firstPlayerState.GatherPile.Cards.Count == 10); Assert.True(firstPlayerState.PlayedCards.Cards.Count == 0); Assert.True(firstPlayerState.PlayPile.Cards.Count == 0); Assert.True(secondPlayerState.GatherPile.Cards.Count == 0); Assert.True(secondPlayerState.PlayedCards.Cards.Count == 0); Assert.True(secondPlayerState.PlayPile.Cards.Count == 0); }
public void WarTestSimpleWar(int winner) { var loggerDouble = new LoggerDouble <PlayWar>(); var singleGameStatsMock = new Mock <ISingleGameStats>(); var winningCard = new Card { Rank = "K", Suit = Constants.Suits.Hearts }; var losingCard = new Card { Rank = "3", Suit = Constants.Suits.Clubs }; var firstPlayerState = new PlayerGameState { PlayPile = new CardPile { Cards = new List <Card> { new Card { Rank = "5", Suit = Constants.Suits.Diamonds }, new Card { Rank = "A", Suit = Constants.Suits.Clubs }, new Card { Rank = "7", Suit = Constants.Suits.Spades }, new Card { Rank = "4", Suit = Constants.Suits.Diamonds }, winner == 1 ? winningCard : losingCard } }, GatherPile = new CardPile { Cards = new List <Card> { } }, PlayedCards = new CardPile { Cards = new List <Card> { } }, }; var secondPlayerState = new PlayerGameState { PlayPile = new CardPile { Cards = new List <Card> { new Card { Rank = "5", Suit = Constants.Suits.Hearts }, new Card { Rank = "2", Suit = Constants.Suits.Clubs }, new Card { Rank = "Q", Suit = Constants.Suits.Hearts }, new Card { Rank = "J", Suit = Constants.Suits.Diamonds }, winner == 2 ? winningCard : losingCard } }, GatherPile = new CardPile { Cards = new List <Card> { } }, PlayedCards = new CardPile { Cards = new List <Card> { } }, }; var gameStateMock = new Mock <ITrackIndividualGameState>(); gameStateMock.Setup(mock => mock.FirstPlayerState).Returns(firstPlayerState); gameStateMock.Setup(mock => mock.SecondPlayerState).Returns(secondPlayerState); var player1WarWinsByDepthTracker = new List <int>() { 0, 0, 0, 0, 0, 0, 0, 0 }; var player2WarWinsByDepthTracker = new List <int>() { 0, 0, 0, 0, 0, 0, 0, 0 }; singleGameStatsMock.Setup(mock => mock.Player1WarWinsByDepth).Returns(player1WarWinsByDepthTracker); singleGameStatsMock.Setup(mock => mock.Player2WarWinsByDepth).Returns(player2WarWinsByDepthTracker); gameStateMock.Setup(mock => mock.Stats).Returns(singleGameStatsMock.Object); var objectUnderTest = new PlayWar(loggerDouble); objectUnderTest.War(gameStateMock.Object); gameStateMock.Verify(mock => mock.Tick(Constants.GamePlayParameters.TimeToPlayCard), Times.Exactly(2)); gameStateMock.Verify(mock => mock.Tick(Constants.GamePlayParameters.TimeToPlayCardsFaceDownForAWar), Times.Once()); gameStateMock.Verify(mock => mock.Tick(Constants.GamePlayParameters.TimeToShuffle), Times.Never()); gameStateMock.Verify(mock => mock.Tick(Constants.GamePlayParameters.TimeToGatherCards), Times.Once()); Assert.True(loggerDouble.HasBeenLogged(LogLevel.Debug, $"Player {winner} wins")); Assert.True(player1WarWinsByDepthTracker[1] == (winner == 1 ? 1 : 0)); Assert.True(player2WarWinsByDepthTracker[1] == (winner == 2 ? 1 : 0)); Assert.True(loggerDouble.HasBeenLogged(LogLevel.Debug, $"War: 5♦ vs 5♥...")); if (winner == 1) { Assert.True(loggerDouble.HasBeenLogged(LogLevel.Debug, $"War: {winningCard} vs {losingCard}...")); } else { Assert.True(loggerDouble.HasBeenLogged(LogLevel.Debug, $"War: {losingCard} vs {winningCard}...")); } var player1verb = (winner == 1 ? "saves" : "loses"); var player2verb = (winner == 2 ? "saves" : "loses"); Assert.True(loggerDouble.HasBeenLogged(LogLevel.Debug, "War with depth 0 on this turn.")); Assert.True(loggerDouble.HasBeenLogged(LogLevel.Debug, $"Player 1 {player1verb}: 5♦")); Assert.True(loggerDouble.HasBeenLogged(LogLevel.Debug, $"Player 1 {player1verb}: A♣")); Assert.True(loggerDouble.HasBeenLogged(LogLevel.Debug, $"Player 1 {player1verb}: 7♠")); Assert.True(loggerDouble.HasBeenLogged(LogLevel.Debug, $"Player 1 {player1verb}: 4♦")); Assert.True(loggerDouble.HasBeenLogged(LogLevel.Debug, $"Player 2 {player2verb}: 5♥")); Assert.True(loggerDouble.HasBeenLogged(LogLevel.Debug, $"Player 2 {player2verb}: 2♣")); Assert.True(loggerDouble.HasBeenLogged(LogLevel.Debug, $"Player 2 {player2verb}: Q♥")); Assert.True(loggerDouble.HasBeenLogged(LogLevel.Debug, $"Player 2 {player2verb}: J♦")); Assert.True(loggerDouble.DebugEntries.Count() == 12); Assert.True(firstPlayerState.GatherPile.Cards.Count == (winner == 1 ? 10 : 0)); Assert.True(firstPlayerState.PlayedCards.Cards.Count == 0); Assert.True(firstPlayerState.PlayPile.Cards.Count == 0); Assert.True(secondPlayerState.GatherPile.Cards.Count == (winner == 2 ? 10 : 0)); Assert.True(secondPlayerState.PlayedCards.Cards.Count == 0); Assert.True(secondPlayerState.PlayPile.Cards.Count == 0); }
public void WarTestWinnerAfterSingleDepthWar(int winner) { var loggerDouble = new LoggerDouble <PlayWar>(); var singleGameStatsMock = new Mock <ISingleGameStats>(); var winningCard = new Card { Rank = "K", Suit = Constants.Suits.Hearts }; var losingCard = new Card { Rank = "3", Suit = Constants.Suits.Clubs }; var firstPlayerState = new PlayerGameState { PlayPile = new CardPile { Cards = new List <Card> { winner == 1 ? winningCard : losingCard } }, GatherPile = new CardPile { Cards = new List <Card> { } }, PlayedCards = new CardPile { Cards = new List <Card> { new Card { Rank = "A", Suit = Constants.Suits.Clubs }, new Card { Rank = "A", Suit = Constants.Suits.Spades }, new Card { Rank = "A", Suit = Constants.Suits.Hearts }, } } }; var secondPlayerState = new PlayerGameState { PlayPile = new CardPile { Cards = new List <Card> { winner == 2 ? winningCard : losingCard } }, GatherPile = new CardPile { Cards = new List <Card> { } }, PlayedCards = new CardPile { Cards = new List <Card> { new Card { Rank = "2", Suit = Constants.Suits.Clubs }, new Card { Rank = "2", Suit = Constants.Suits.Spades }, new Card { Rank = "2", Suit = Constants.Suits.Hearts }, } } }; var gameStateMock = new Mock <ITrackIndividualGameState>(); gameStateMock.Setup(mock => mock.FirstPlayerState).Returns(firstPlayerState); gameStateMock.Setup(mock => mock.SecondPlayerState).Returns(secondPlayerState); var player1WarWinsByDepthTracker = new List <int>() { 0, 0, 0, 0, 0, 0, 0, 0 }; var player2WarWinsByDepthTracker = new List <int>() { 0, 0, 0, 0, 0, 0, 0, 0 }; singleGameStatsMock.Setup(mock => mock.Player1WarWinsByDepth).Returns(player1WarWinsByDepthTracker); singleGameStatsMock.Setup(mock => mock.Player2WarWinsByDepth).Returns(player2WarWinsByDepthTracker); gameStateMock.Setup(mock => mock.Stats).Returns(singleGameStatsMock.Object); var objectUnderTest = new PlayWar(loggerDouble); objectUnderTest.War(gameStateMock.Object, warDepth: 1); gameStateMock.Verify(mock => mock.Tick(Constants.GamePlayParameters.TimeToPlayCard), Times.Once()); gameStateMock.Verify(mock => mock.Tick(Constants.GamePlayParameters.TimeToGatherCards), Times.Once()); Assert.True(loggerDouble.HasBeenLogged(LogLevel.Debug, $"Player {winner} wins")); Assert.True(player1WarWinsByDepthTracker[1] == (winner == 1 ? 1 : 0)); Assert.True(player2WarWinsByDepthTracker[1] == (winner == 2 ? 1 : 0)); if (winner == 1) { Assert.True(loggerDouble.HasBeenLogged(LogLevel.Debug, $"War: {winningCard} vs {losingCard}...")); } else { Assert.True(loggerDouble.HasBeenLogged(LogLevel.Debug, $"War: {losingCard} vs {winningCard}...")); } var player1verb = (winner == 1 ? "saves" : "loses"); var player2verb = (winner == 2 ? "saves" : "loses"); Assert.True(loggerDouble.HasBeenLogged(LogLevel.Debug, $"Player 1 {player1verb}: A♣")); Assert.True(loggerDouble.HasBeenLogged(LogLevel.Debug, $"Player 1 {player1verb}: A♥")); Assert.True(loggerDouble.HasBeenLogged(LogLevel.Debug, $"Player 1 {player1verb}: A♠")); Assert.True(loggerDouble.HasBeenLogged(LogLevel.Debug, $"Player 2 {player2verb}: 2♣")); Assert.True(loggerDouble.HasBeenLogged(LogLevel.Debug, $"Player 2 {player2verb}: 2♥")); Assert.True(loggerDouble.HasBeenLogged(LogLevel.Debug, $"Player 2 {player2verb}: 2♠")); Assert.True(loggerDouble.DebugEntries.Count() == 8); Assert.True(firstPlayerState.GatherPile.Cards.Count == (winner == 1 ? 8 : 0)); Assert.True(firstPlayerState.PlayedCards.Cards.Count == 0); Assert.True(firstPlayerState.PlayPile.Cards.Count == 0); Assert.True(secondPlayerState.GatherPile.Cards.Count == (winner == 2 ? 8 : 0)); Assert.True(secondPlayerState.PlayedCards.Cards.Count == 0); Assert.True(secondPlayerState.PlayPile.Cards.Count == 0); }
public void WarTestSimpleCase(int winner) { var loggerDouble = new LoggerDouble <PlayWar>(); var winningCard = new Card { Rank = "K", Suit = Constants.Suits.Hearts }; var losingCard = new Card { Rank = "3", Suit = Constants.Suits.Clubs }; var firstPlayerState = new PlayerGameState { PlayPile = new CardPile { Cards = new List <Card> { winner == 1 ? winningCard : losingCard } }, GatherPile = new CardPile { Cards = new List <Card> { } }, PlayedCards = new CardPile { Cards = new List <Card> { } } }; var secondPlayerState = new PlayerGameState { PlayPile = new CardPile { Cards = new List <Card> { winner == 2 ? winningCard : losingCard } }, GatherPile = new CardPile { Cards = new List <Card> { } }, PlayedCards = new CardPile { Cards = new List <Card> { } } }; var gameStateMock = new Mock <ITrackIndividualGameState>(); gameStateMock.Setup(mock => mock.FirstPlayerState).Returns(firstPlayerState); gameStateMock.Setup(mock => mock.SecondPlayerState).Returns(secondPlayerState); var objectUnderTest = new PlayWar(loggerDouble); objectUnderTest.War(gameStateMock.Object); gameStateMock.Verify(mock => mock.Tick(Constants.GamePlayParameters.TimeToPlayCard), Times.Once()); gameStateMock.Verify(mock => mock.Tick(Constants.GamePlayParameters.TimeToGatherCards), Times.Once()); Assert.True(loggerDouble.HasBeenLogged(LogLevel.Debug, $"Player {winner} wins")); if (winner == 1) { Assert.True(loggerDouble.HasBeenLogged(LogLevel.Debug, $"War: {winningCard} vs {losingCard}...")); } else { Assert.True(loggerDouble.HasBeenLogged(LogLevel.Debug, $"War: {losingCard} vs {winningCard}...")); } Assert.True(loggerDouble.DebugEntries.Count() == 2); Assert.True(firstPlayerState.GatherPile.Cards.Count == (winner == 1 ? 2 : 0)); Assert.True(firstPlayerState.PlayedCards.Cards.Count == 0); Assert.True(firstPlayerState.PlayPile.Cards.Count == 0); Assert.True(secondPlayerState.GatherPile.Cards.Count == (winner == 2 ? 2 : 0)); Assert.True(secondPlayerState.PlayedCards.Cards.Count == 0); Assert.True(secondPlayerState.PlayPile.Cards.Count == 0); }
public void PlayTestWhenSimulationEndsAfterTwoTieGamesInARow() { var loggerDouble = new LoggerDouble <CoordinateGameplay>(); var gamePlayMock = new Mock <IPlayWar>(); var pointsCalculatorMock = new Mock <IPointsCalculator>(); var individualGameStateTrackerMock = new Mock <ITrackIndividualGameState>(); var timerMock = new Mock <IDateTime>(); var statsCompilerMock = new Mock <ICompileStats>(); var singleGameStatsMock = new Mock <ISingleGameStats>(); var dummyStart = new DateTime(year: 2011, month: 8, day: 23, hour: 16, minute: 0, second: 0); var dummySimulationEnd = new DateTime(year: 2011, month: 8, day: 23, hour: 16, minute: 0, second: 3); // 3 seconds later timerMock.SetupSequence(mock => mock.Now) .Returns(dummyStart) .Returns(dummySimulationEnd); // use a real game state to easily initialize a full deck var realGameState = new TrackIndividualGameState().InitializeGameState(); var fakeGameState = new Mock <ITrackIndividualGameState>(); var player1DummyState = realGameState.FirstPlayerState; var player2DummyState = realGameState.SecondPlayerState; fakeGameState.Setup(mock => mock.FirstPlayerState).Returns(player1DummyState); fakeGameState.Setup(mock => mock.SecondPlayerState).Returns(player2DummyState); fakeGameState.SetupSequence(mock => mock.TimeElapsed) .Returns(TimeSpan.FromMinutes(4)) // first game 4 minutes .Returns(TimeSpan.FromMinutes(4)) // but TimeElapsed is invoked ... .Returns(TimeSpan.FromMinutes(4)) // three times .Returns(TimeSpan.FromMinutes(7)) // second game 7 minutes .Returns(TimeSpan.FromMinutes(7)) // but TimeElapsed gets invoked ... .Returns(TimeSpan.FromMinutes(7)); // trhee times fakeGameState.Setup(mock => mock.Stats).Returns(singleGameStatsMock.Object); gamePlayMock.Setup(mock => mock.PlayerHasLost(It.IsAny <PlayerGameState>())).Returns(false); fakeGameState.SetupSequence(mock => mock.TimedOut) .Returns(false) .Returns(false) .Returns(true) .Returns(false) .Returns(true); individualGameStateTrackerMock.Setup(mock => mock.InitializeGameState()).Returns(fakeGameState.Object); pointsCalculatorMock.Setup(mock => mock.GetPoints(It.IsAny <List <Card> >())).Returns(48); // always return a tie var objectUnderTest = new CoordinateGameplay(loggerDouble, gamePlayMock.Object, pointsCalculatorMock.Object, individualGameStateTrackerMock.Object, timerMock.Object, statsCompilerMock.Object); var dummySimulationDuration = TimeSpan.FromMinutes(10); var dummyGameParams = new GameParameters { FirstPlayerName = "Isaac", SecondPlayerName = "Daddy", TotalLengthOfSimulation = dummySimulationDuration }; var result = objectUnderTest.Play(dummyGameParams); Assert.True(result.TotalSimulationTime == (dummySimulationEnd - dummyStart)); Assert.True(loggerDouble.DebugEntries.Count() == 8); Assert.True(loggerDouble.InformationEntries.Count() == 1); Assert.True(loggerDouble.HasBeenLogged(LogLevel.Debug, $"{ dummyGameParams.FirstPlayerName} has 0 wins, " + $"{dummyGameParams.SecondPlayerName} has 0 wins, 1 ties")); Assert.True(loggerDouble.HasBeenLogged(LogLevel.Debug, $"{ dummyGameParams.FirstPlayerName} has 0 wins, " + $"{dummyGameParams.SecondPlayerName} has 0 wins, 2 ties")); Assert.True(loggerDouble.HasBeenLogged(LogLevel.Debug, "This game is a tie.")); Assert.True(loggerDouble.HasBeenLogged(LogLevel.Debug, "Game has timed out after 240 seconds.")); Assert.True(loggerDouble.HasBeenLogged(LogLevel.Debug, "Game has timed out after 420 seconds.")); Assert.True(loggerDouble.HasBeenLogged(LogLevel.Information, "Simulation took 3 seconds...")); gamePlayMock.Verify(mock => mock.War(It.IsAny <ITrackIndividualGameState>(), It.IsAny <int>()), Times.Exactly(5)); gamePlayMock.Verify(mock => mock.Transition(It.IsAny <ITrackIndividualGameState>()), Times.Exactly(5)); pointsCalculatorMock.Verify(mock => mock.GetPoints(It.IsAny <List <Card> >()), Times.Exactly(4)); singleGameStatsMock.VerifySet(mock => mock.Winner = 0, Times.Exactly(2)); singleGameStatsMock.VerifySet(mock => mock.SimulationTime = It.IsAny <TimeSpan>(), Times.Exactly(2)); statsCompilerMock.Verify(mock => mock.UpdateStats(It.IsAny <ISimulationStats>(), It.IsAny <ISingleGameStats>()), Times.Exactly(2)); }
public void PlayTestWhenOnePlayerLosesImmediatelyAndThenWeTimeOut(int winner) { var loggerDouble = new LoggerDouble <CoordinateGameplay>(); var gamePlayMock = new Mock <IPlayWar>(); var pointsCalculatorMock = new Mock <IPointsCalculator>(); var individualGameStateTrackerMock = new Mock <ITrackIndividualGameState>(); var timerMock = new Mock <IDateTime>(); var statsCompilerMock = new Mock <ICompileStats>(); var singleGameStatsMock = new Mock <ISingleGameStats>(); var dummyStart = new DateTime(year: 2011, month: 8, day: 23, hour: 16, minute: 0, second: 0); var dummySimulationEnd = new DateTime(year: 2011, month: 8, day: 23, hour: 16, minute: 0, second: 3); // 3 seconds later timerMock.SetupSequence(mock => mock.Now) .Returns(dummyStart) .Returns(dummySimulationEnd); var fakeGameState = new Mock <ITrackIndividualGameState>(); var player1DummyState = new PlayerGameState { }; var player2DummyState = new PlayerGameState { }; fakeGameState.Setup(mock => mock.FirstPlayerState).Returns(player1DummyState); fakeGameState.Setup(mock => mock.SecondPlayerState).Returns(player2DummyState); var dummyDuration = TimeSpan.FromMinutes(5); fakeGameState.Setup(mock => mock.TimeElapsed).Returns(dummyDuration); fakeGameState.Setup(mock => mock.Stats).Returns(singleGameStatsMock.Object); gamePlayMock.Setup(mock => mock.PlayerHasLost(player1DummyState)).Returns(winner == 2); gamePlayMock.Setup(mock => mock.PlayerHasLost(player2DummyState)).Returns(winner == 1); individualGameStateTrackerMock.Setup(mock => mock.InitializeGameState()).Returns(fakeGameState.Object); var objectUnderTest = new CoordinateGameplay(loggerDouble, gamePlayMock.Object, pointsCalculatorMock.Object, individualGameStateTrackerMock.Object, timerMock.Object, statsCompilerMock.Object); var dummySimulationDuration = TimeSpan.FromMinutes(4); var dummyGameParams = new GameParameters { FirstPlayerName = "Isaac", SecondPlayerName = "Daddy", TotalLengthOfSimulation = dummySimulationDuration }; var result = objectUnderTest.Play(dummyGameParams); Assert.True(result.TotalSimulationTime == (dummySimulationEnd - dummyStart)); Assert.True(loggerDouble.DebugEntries.Count() == 3); Assert.True(loggerDouble.InformationEntries.Count() == 1); Assert.True(loggerDouble.HasBeenLogged(LogLevel.Debug, $"{ dummyGameParams.FirstPlayerName} has { (winner == 1 ? 1 : 0)} wins, " + $"{dummyGameParams.SecondPlayerName} has {(winner == 2 ? 1 : 0)} wins, 0 ties")); Assert.True(loggerDouble.HasBeenLogged(LogLevel.Debug, $"Player {winner} has won this game!")); Assert.True(loggerDouble.HasBeenLogged(LogLevel.Information, "Simulation took 3 seconds...")); //make sure we only played war once gamePlayMock.Verify(mock => mock.War(It.IsAny <ITrackIndividualGameState>(), It.IsAny <int>()), Times.Once()); //make sure we never had to transition gamePlayMock.Verify(mock => mock.Transition(It.IsAny <ITrackIndividualGameState>()), Times.Never()); //make sure there was no need to calculate points pointsCalculatorMock.Verify(mock => mock.GetPoints(It.IsAny <List <Card> >()), Times.Never()); singleGameStatsMock.VerifySet(mock => mock.Winner = winner, Times.Once()); singleGameStatsMock.VerifySet(mock => mock.SimulationTime = It.IsAny <TimeSpan>(), Times.Once()); statsCompilerMock.Verify(mock => mock.UpdateStats(It.IsAny <ISimulationStats>(), It.IsAny <ISingleGameStats>()), Times.Once()); }
public void PlayTestWhenWithTimeoutButAWinner(int winner) { var loggerDouble = new LoggerDouble <CoordinateGameplay>(); var gamePlayMock = new Mock <IPlayWar>(); var pointsCalculatorMock = new Mock <IPointsCalculator>(); var individualGameStateTrackerMock = new Mock <ITrackIndividualGameState>(); var timerMock = new Mock <IDateTime>(); var statsCompilerMock = new Mock <ICompileStats>(); var singleGameStatsMock = new Mock <ISingleGameStats>(); // use a real game state to easily initialize a full deck var realGameState = new TrackIndividualGameState().InitializeGameState(); var fakeGameState = new Mock <ITrackIndividualGameState>(); var player1DummyState = realGameState.FirstPlayerState; var player2DummyState = realGameState.SecondPlayerState; fakeGameState.Setup(mock => mock.FirstPlayerState).Returns(player1DummyState); fakeGameState.Setup(mock => mock.SecondPlayerState).Returns(player2DummyState); var dummyDuration = TimeSpan.FromMinutes(10); fakeGameState.Setup(mock => mock.TimeElapsed).Returns(dummyDuration); gamePlayMock.Setup(mock => mock.PlayerHasLost(It.IsAny <PlayerGameState>())).Returns(false); fakeGameState.Setup(mock => mock.TimedOut).Returns(true); fakeGameState.Setup(mock => mock.Stats).Returns(singleGameStatsMock.Object); individualGameStateTrackerMock.Setup(mock => mock.InitializeGameState()).Returns(fakeGameState.Object); pointsCalculatorMock.SetupSequence(mock => mock.GetPoints(It.IsAny <List <Card> >())) .Returns(winner == 1 ? 49 : 47) .Returns(winner == 2 ? 49 : 47); var objectUnderTest = new CoordinateGameplay(loggerDouble, gamePlayMock.Object, pointsCalculatorMock.Object, individualGameStateTrackerMock.Object, timerMock.Object, statsCompilerMock.Object); var dummySimulationDuration = TimeSpan.FromMinutes(10); var dummyGameParams = new GameParameters { FirstPlayerName = "Isaac", SecondPlayerName = "Daddy", TotalLengthOfSimulation = dummySimulationDuration }; objectUnderTest.Play(dummyGameParams); Assert.True(loggerDouble.DebugEntries.Count() == 4); Assert.True(loggerDouble.InformationEntries.Count() == 1); Assert.True(loggerDouble.HasBeenLogged(LogLevel.Debug, $"{ dummyGameParams.FirstPlayerName} has {(winner == 1 ? 1 : 0)} wins, " + $"{dummyGameParams.SecondPlayerName} has {(winner == 2 ? 1 : 0)} wins, 0 ties")); Assert.True(loggerDouble.HasBeenLogged(LogLevel.Debug, $"Player {winner} has won this game!")); gamePlayMock.Verify(mock => mock.War(It.IsAny <ITrackIndividualGameState>(), It.IsAny <int>()), Times.Once()); gamePlayMock.Verify(mock => mock.Transition(It.IsAny <ITrackIndividualGameState>()), Times.Once()); pointsCalculatorMock.Verify(mock => mock.GetPoints(It.IsAny <List <Card> >()), Times.Exactly(2)); singleGameStatsMock.VerifySet(mock => mock.Winner = winner, Times.Once()); singleGameStatsMock.VerifySet(mock => mock.SimulationTime = It.IsAny <TimeSpan>(), Times.Once()); statsCompilerMock.Verify(mock => mock.UpdateStats(It.IsAny <ISimulationStats>(), It.IsAny <ISingleGameStats>()), Times.Once()); }