public async Task TestPostingValidSet()
{
SeedDTO seed = new SeedDTO {
Seed = 42
};
StringContent postContent = TestUtilities.ObjToStringContent(seed);
HttpClient client = TestUtilities.GetHttpClient();
HttpResponseMessage response = await client.PostAsync("newgame", postContent);
string content = await response.Content.ReadAsStringAsync();
BoardDTO gameObj = JsonConvert.DeserializeObject <BoardDTO>(content);
List <Card> cards = TestUtilities.FindSet(gameObj.Cards);
GuessDTO guess = new GuessDTO {
GameID = gameObj.GameID, Card1 = cards[0], Card2 = cards[1], Card3 = cards[2]
};
StringContent guessContent = TestUtilities.ObjToStringContent(guess);
HttpResponseMessage postResponse = await client.PostAsync("submitguess", guessContent);
string responseContent = await postResponse.Content.ReadAsStringAsync();
GameDTO gameDTO = JsonConvert.DeserializeObject <GameDTO>(responseContent);
Assert.AreEqual(true, gameDTO.ValidSet, "Posted cards should have registered as valid but are invalid");
Assert.AreEqual(78, gameDTO.CardsRemaining, "Cards remaining should have been 78 but are not");
Assert.IsFalse(gameDTO.WinState, "Win state after a single POST should be false but is true");
Assert.IsFalse(TestUtilities.BoardContainsCards(gameDTO.Board, guess.Card1, guess.Card2, guess.Card3), "Posted cards should be removed from the board but are still present");
}
public GameDTO TryGuesst(GuessDTO guess)
{
var game = gamesRepository.Get(guess.Id);
if (game == null)
{
throw new GameException("Game Id is not valid");
}
if (game.Status != Domian.Enums.GameStatus.pending)
{
throw new GameException("Game already ended");
}
HandleIfTimesUp(game);
Check(game, guess.Number);
gamesRepository.Edit(game);
var result = new GameDTO();
result.Status = game.Status;
if (game.Status == Domian.Enums.GameStatus.won)
{
AddToHightScores(game, result);
}
return(result);
}
public IActionResult PostSelectedCards(GuessDTO guess)
{
GameResult gameResult = GameHolder.RetrieveGame(guess.GameID);
if (!gameResult.ValidGameID)
{
return(BadRequest());
}
Game game = gameResult.GameObj;
if (!game.ValidCards(guess.Card1, guess.Card2, guess.Card3) || game.WinState)
{
return(BadRequest());
}
bool validSet = game.MakeGuess(guess.Card1, guess.Card2, guess.Card3);
return(Ok(new GameDTO
{
GameID = guess.GameID,
Board = game.Board,
ValidSet = validSet,
WinState = game.WinState,
CardsRemaining = game.CardsRemaining,
TopScores = new List <Player>()
}));
}
public async Task TestReset()
{
SeedDTO seed = new SeedDTO {
Seed = 42
};
StringContent postContent = TestUtilities.ObjToStringContent(seed);
HttpClient client = TestUtilities.GetHttpClient();
HttpResponseMessage response = await client.PostAsync("newgame", postContent);
string content = await response.Content.ReadAsStringAsync();
BoardDTO gameObj = JsonConvert.DeserializeObject <BoardDTO>(content);
List <Card> cards = TestUtilities.FindSet(gameObj.Cards);
GuessDTO guess = new GuessDTO {
GameID = gameObj.GameID, Card1 = cards[0], Card2 = cards[1], Card3 = cards[2]
};
StringContent guessContent = TestUtilities.ObjToStringContent(guess);
HttpResponseMessage postResponse = await client.PostAsync("submitguess", guessContent);
string responseContent = await postResponse.Content.ReadAsStringAsync();
gameDTO = JsonConvert.DeserializeObject <GameDTO>(responseContent);
Assert.IsFalse(gameDTO.WinState, "After a reset, game marked as won still");
Assert.AreEqual(78, gameDTO.CardsRemaining, "After a reset, expected 78 cards remaining but actual was different");
}
public async Task TestSetup()
{
SeedDTO seed = new SeedDTO {
Seed = 42
};
StringContent postContent = TestUtilities.ObjToStringContent(seed);
HttpClient client = TestUtilities.GetHttpClient();
HttpResponseMessage response = await client.PostAsync("newgame", postContent);
string content = await response.Content.ReadAsStringAsync();
BoardDTO gameObj = JsonConvert.DeserializeObject <BoardDTO>(content);
gameDTO = new GameDTO {
Board = gameObj.Cards, GameID = gameObj.GameID
};
for (int i = 0; i < 24; i++)
{
List <Card> cards = TestUtilities.FindSet(gameDTO.Board);
GuessDTO guess = new GuessDTO {
GameID = gameDTO.GameID, Card1 = cards[0], Card2 = cards[1], Card3 = cards[2]
};
StringContent guessContent = TestUtilities.ObjToStringContent(guess);
HttpResponseMessage postResponse = await client.PostAsync("submitguess", guessContent);
string responseContent = await postResponse.Content.ReadAsStringAsync();
gameDTO = JsonConvert.DeserializeObject <GameDTO>(responseContent);
}
}
public async Task TestInvalidSetNotOnBoard()
{
HttpClient client = TestUtilities.GetHttpClient();
Card card1 = new Card(Characteristic.Option1, Characteristic.Option1, Characteristic.Option1, Characteristic.Option1);
Card card2 = new Card(Characteristic.Option1, Characteristic.Option1, Characteristic.Option2, Characteristic.Option1);
Card card3 = new Card(Characteristic.Option1, Characteristic.Option1, Characteristic.Option3, Characteristic.Option1);
GuessDTO notOnBoard = new GuessDTO {
GameID = gameDTO.GameID, Card1 = card1, Card2 = card2, Card3 = card3
};
StringContent guessContent = TestUtilities.ObjToStringContent(notOnBoard);
HttpResponseMessage postResponse = await client.PostAsync("submitguess", guessContent);
Assert.AreEqual(HttpStatusCode.BadRequest, postResponse.StatusCode);
}
public void TryGuessNumber_NumberOutOfRange()
{
var game = new NewGameDTO().ToNewGameModel();
game.Id = "ABCDE";
var gameService = GetSampleGameService(game);
var guess = new GuessDTO
{
Id = game.Id,
Number = game.From - 1
};
Assert.Throws <GameException>(() => gameService.TryGuesst(guess));
}
public async Task TestInvalidSet()
{
HttpClient client = TestUtilities.GetHttpClient();
GuessDTO notASet = new GuessDTO {
GameID = gameDTO.GameID, Card1 = gameDTO.Board[0], Card2 = gameDTO.Board[1], Card3 = gameDTO.Board[2]
};
StringContent guessContent = TestUtilities.ObjToStringContent(notASet);
HttpResponseMessage postResponse = await client.PostAsync("submitguess", guessContent);
string responseContent = await postResponse.Content.ReadAsStringAsync();
gameDTO = JsonConvert.DeserializeObject <GameDTO>(responseContent);
Assert.IsFalse(gameDTO.ValidSet, "Posted cards should have been an invalid set but are a valid set");
Assert.IsTrue(TestUtilities.BoardContainsCards(gameDTO.Board, notASet.Card1, notASet.Card2, notASet.Card3), "The board no longer contains the invalid set cards");
}
public void TryGuessNumber_TimeUp()
{
var game = new NewGameDTO().ToNewGameModel();
game.Id = "ABCDE";
game.LastAttemptDate = game.LastAttemptDate.AddDays(-1);
var gameService = GetSampleGameService(game);
var guess = new GuessDTO
{
Id = game.Id,
Number = game.Number
};
Assert.Throws <GameException>(() => gameService.TryGuesst(guess));
}
public async Task <ActionResult <ResultDTO> > PostQuiz(int quizId, [FromBody] GuessDTO dto)
{
var quiz = await _context.Quizes.FindAsync(quizId);
if (quiz is null)
{
return(BadRequest("Quiz doesnt exist"));
}
var qs = await _context.Questions.Where(q => q.Quiz == quiz)
.Include(q => q.AnswerOptions).ToListAsync();
var result = _quizChecker.CheckQuiz(qs, dto);
result.QuizId = quizId;
return(result);
}
public async Task <ComputerAnswerDTO> Play(ValueOnlyGuessDTO ValueOnlyUserGuessDTO)
{
if (!ModelState.IsValid)
{
return(null);
}
Game game = await _gameHandler.GetActiveGame(HttpContext);
_context.Attach(game);
if (game == null)
{
return(null);
}
GuessOutcome userGuessOutcome = await _gameHandler.GetUserGuessOutcome(HttpContext, ValueOnlyUserGuessDTO.Value);
Guess userGuess = new Guess()
{
Value = ValueOnlyUserGuessDTO.Value,
GuessOutcome = userGuessOutcome,
GuessMaker = GuessMaker.User,
Game = game
};
_context.Attach(userGuess);
string AIGuess = await _gameHandler.GetAIGuess(HttpContext);
GuessOutcome aiGuessOutcomeDTO = await _gameHandler.GetAIGuessOutcome(HttpContext, AIGuess);
Guess aiGuess = new Guess()
{
Value = AIGuess,
GuessOutcome = aiGuessOutcomeDTO,
GuessMaker = GuessMaker.AI,
Game = game
};
_context.Attach(aiGuess);
GuessDTO aiGuessDTO = new GuessDTO(aiGuess);
GuessDTO userGuessDTO = new GuessDTO(userGuess);
ComputerAnswerDTO computerAnswer = new ComputerAnswerDTO
{
AIGuess = aiGuessDTO,
UserGuess = userGuessDTO
};
if (userGuessOutcome.BullsNumber == ValueOnlyUserGuessDTO.Value.Length)//All numbers match - User wins
{
game.WonByUser = true;
computerAnswer.UserVictory = true;
computerAnswer.AIGuess = null;
}
else if (aiGuessOutcomeDTO.BullsNumber == AIGuess.Length)//All numbers match - AI wins
{
game.WonByAI = true;
computerAnswer.AIVictory = true;
}
await _context.SaveChangesAsync();
return(computerAnswer);
}
public IActionResult Guess([FromBody] GuessDTO guess)
{
var result = gameService.TryGuesst(guess);
return(Ok(result.ToString()));
}
