test(acceptance): acceptances tests for raven (#459)

src/modules/game/providers/services/game-history/game-history-record.service.ts

@@ -163,8 +163,7 @@ export class GameHistoryRecordService {
     newGame: Game,
     gameHistoryRecordToInsert: GameHistoryRecordToInsert,
   ): GameHistoryRecordPlayVoting {
-    const votes = gameHistoryRecordToInsert.play.votes ?? [];
-    const nominatedPlayers = this.gamePlayVoteService.getNominatedPlayers(votes, baseGame);
+    const nominatedPlayers = this.gamePlayVoteService.getNominatedPlayers(gameHistoryRecordToInsert.play.votes, baseGame);
     const gameHistoryRecordPlayVoting: GameHistoryRecordPlayVoting = {
       result: this.generateCurrentGameHistoryRecordPlayVotingResultToInsert(baseGame, newGame, gameHistoryRecordToInsert),
       nominatedPlayers,

src/modules/game/providers/services/game-play/game-play-maker.service.ts

@@ -125,9 +125,6 @@ export class GamePlayMakerService {
 
   private async allVote({ votes, doesJudgeRequestAnotherVote }: MakeGamePlayWithRelationsDto, game: GameWithCurrentPlay): Promise<Game> {
     let clonedGame = createGame(game) as GameWithCurrentPlay;
-    if (!votes) {
-      return clonedGame;
-    }
     const nominatedPlayers = this.gamePlayVoteService.getNominatedPlayers(votes, clonedGame);
     if (doesJudgeRequestAnotherVote === true) {
       const gamePlayAllVote = createGamePlayAllVote({ cause: GamePlayCauses.STUTTERING_JUDGE_REQUEST });
@@ -160,9 +157,6 @@ export class GamePlayMakerService {
   private allElectSheriff(play: MakeGamePlayWithRelationsDto, game: GameWithCurrentPlay): Game {
     const clonedGame = createGame(game) as GameWithCurrentPlay;
     const { votes } = play;
-    if (!votes) {
-      return clonedGame;
-    }
     const nominatedPlayers = this.gamePlayVoteService.getNominatedPlayers(votes, clonedGame);
     if (!nominatedPlayers.length) {
       return clonedGame;

src/modules/game/providers/services/game-play/game-play-vote/game-play-vote.service.ts

@@ -14,15 +14,18 @@ import { RoleNames } from "@/modules/role/enums/role.enum";
 
 @Injectable()
 export class GamePlayVoteService {
-  public getNominatedPlayers(votes: MakeGamePlayVoteWithRelationsDto[], game: GameWithCurrentPlay): Player[] {
+  public getNominatedPlayers(votes: MakeGamePlayVoteWithRelationsDto[] | undefined, game: GameWithCurrentPlay): Player[] {
     const clonedGame = createGame(game) as GameWithCurrentPlay;
     let playerVoteCounts = this.getPlayerVoteCounts(votes, clonedGame);
     playerVoteCounts = this.addRavenMarkVoteToPlayerVoteCounts(playerVoteCounts, clonedGame);
     const maxVotes = Math.max(...playerVoteCounts.map(playerVoteCount => playerVoteCount[1]));
     return playerVoteCounts.filter(playerVoteCount => playerVoteCount[1] === maxVotes).map(playerVoteCount => createPlayer(playerVoteCount[0]));
   }
 
-  private getPlayerVoteCounts(votes: MakeGamePlayVoteWithRelationsDto[], game: GameWithCurrentPlay): PlayerVoteCount[] {
+  private getPlayerVoteCounts(votes: MakeGamePlayVoteWithRelationsDto[] | undefined, game: GameWithCurrentPlay): PlayerVoteCount[] {
+    if (!votes) {
+      return [];
+    }
     const { hasDoubledVote: doesSheriffHaveDoubledVote } = game.options.roles.sheriff;
     const sheriffPlayer = getPlayerWithActiveAttributeName(game, PlayerAttributeNames.SHERIFF);
     return votes.reduce<PlayerVoteCount[]>((acc, vote) => {

tests/acceptance/features/game/data/raven-mark-penalty-is-three-option.json

@@ -0,0 +1,7 @@
+{
+  "roles": {
+    "raven": {
+      "markPenalty": 3
+    }
+  }
+}

tests/acceptance/features/game/features/role/raven.feature

@@ -0,0 +1,71 @@
+@raven-role
+
+Feature: 🐦‍⬛ Raven role
+
+  Scenario: 🐦‍⬛ Raven marks a player but can also skip
+    Given a created game with options described in file no-sheriff-option.json and with the following players
+      | name    | role     |
+      | Antoine | raven    |
+      | Olivia  | werewolf |
+      | JB      | villager |
+      | Camille | villager |
+      | Thomas  | villager |
+    Then the game's current play should be raven to mark
+
+    When the player or group skips his turn
+    Then nobody should have the active raven-marked from raven attribute
+    And the game's current play should be werewolves to eat
+
+    When the werewolves eat the player named Thomas
+    Then the player named Thomas should be murdered by werewolves from eaten
+    And the game's current play should be all to vote
+
+    When the player or group skips his turn
+    Then the game's current play should be raven to mark
+
+    When the raven marks the player named JB
+    Then the player named JB should have the active raven-marked from raven attribute
+    And the game's current play should be werewolves to eat
+
+    When the werewolves eat the player named JB
+    Then the player named JB should be murdered by werewolves from eaten
+    And the player named JB should not have the active raven-marked from raven attribute
+
+    When the player or group skips his turn
+    Then the game's current play should be raven to mark
+
+    When the raven marks the player named Antoine
+    Then the player named Antoine should have the active raven-marked from raven attribute
+    And the game's current play should be werewolves to eat
+
+    When the werewolves eat the player named Camille
+    Then the player named Camille should be murdered by werewolves from eaten
+    And the game's current play should be all to vote
+
+    When the player or group skips his turn
+    Then the player named Antoine should be murdered by all from vote
+
+  Scenario: 🐦‍⬛ Raven marks a player with a greater mark than the default one with good option
+    Given a created game with options described in file no-sheriff-option.json, raven-mark-penalty-is-three-option.json and with the following players
+      | name    | role     |
+      | Antoine | raven    |
+      | Olivia  | werewolf |
+      | JB      | villager |
+      | Camille | villager |
+      | Thomas  | villager |
+    Then the game's current play should be raven to mark
+
+    When the raven marks the player named JB
+    Then the player named JB should have the active raven-marked from raven attribute
+    And the game's current play should be werewolves to eat
+
+    When the werewolves eat the player named Thomas
+    Then the player named Thomas should be murdered by werewolves from eaten
+    And the game's current play should be all to vote
+
+    When all vote with the following votes
+      | voter   | target  |
+      | Olivia  | Camille |
+      | JB      | Camille |
+      | Antoine | Olivia  |
+    Then the player named JB should be murdered by all from vote

tests/acceptance/features/game/step-definitions/game.when-steps.ts

@@ -193,6 +193,14 @@ When(/^the thief chooses card with role (?<cardRole>.+)$/u, async function(this:
   this.game = this.response.json<Game>();
 });
 
+When(/^the raven marks the player named (?<name>.+)$/u, async function(this: CustomWorld, targetName: string): Promise<void> {
+  const target = getPlayerWithNameOrThrow(targetName, this.game, new Error("Player name not found"));
+  const makeGamePlayDto: MakeGamePlayDto = { targets: [{ playerId: target._id }] };
+
+  this.response = await makeGamePlayRequest(makeGamePlayDto, this.game, this.app);
+  this.game = this.response.json<Game>();
+});
+
 When(/^the player or group skips his turn$/u, async function(this: CustomWorld): Promise<void> {
   this.response = await makeGamePlayRequest({}, this.game, this.app);
   this.game = this.response.json<Game>();