@Test
 public void statsDontGetPublishedToActivePlayersIfGameNotOver()
     throws com.yazino.game.api.GameException {
   whenGameStart();
   com.yazino.game.api.GamePlayer p1 =
       new com.yazino.game.api.GamePlayer(PLAYER1_ID, SESSION_ID, "");
   com.yazino.game.api.GamePlayer p2 =
       new com.yazino.game.api.GamePlayer(PLAYER2_ID, SESSION_ID, "");
   whenPlayers(p1, p2);
   when(gameRules.getObservableStatus(gameStatus1, getContextFor(p1)))
       .thenReturn(new PrintlnStatus());
   when(gameRules.getObservableStatus(gameStatus1, getContextFor(p2)))
       .thenReturn(new PrintlnStatus());
   when(gameRules.isComplete(gameStatus1)).thenReturn(false);
   final com.yazino.game.api.ExecutionResult result =
       new com.yazino.game.api.ExecutionResult.Builder(gameRules, gameStatus1)
           .scheduledEvents(emptyEvents)
           .build();
   when(gameRules.execute(
           isA(com.yazino.game.api.ExecutionContext.class), eq(command.toCommand(PLAYER_NAME))))
       .thenReturn(result);
   executeCommand();
   verify(locationService, times(2))
       .notify(
           any(BigDecimal.class),
           any(BigDecimal.class),
           any(LocationChangeType.class),
           any(Location.class));
   verifyNoMoreInteractions(locationService);
 }
 @Test
 public void tournamentTableShouldNotRetrievePlayersMainAccount() {
   table.setShowInLobby(false);
   table.setGameId(1l);
   host = gameHost(new InMemoryGameRepository(gameRules));
   BigDecimal playerId = BigDecimal.valueOf(54321);
   CommandWrapper aCommand =
       new CommandWrapper(table.getTableId(), 1l, playerId, SESSION_ID, "aCommand");
   aCommand.setRequestId(UUID);
   when(playerRepository.findSummaryByPlayerAndSession(playerId, SESSION_ID))
       .thenReturn(
           aPlayerSessionSummary(playerId, "", BigDecimal.valueOf(10), BigDecimal.valueOf(100)));
   List<HostDocument> documents = host.execute(table, aCommand);
   assertEquals(1, documents.size());
   assertThat((ErrorHostDocument) documents.get(0), Matchers.isA(ErrorHostDocument.class));
 }
  @Test
  public void testPlayersGetNewStatus() throws com.yazino.game.api.GameException {
    whenGameStart();
    command = commandFrom(PLAYER1_ID);
    com.yazino.game.api.GamePlayer p1 =
        new com.yazino.game.api.GamePlayer(PLAYER1_ID, SESSION_ID, "");
    com.yazino.game.api.GamePlayer p2 =
        new com.yazino.game.api.GamePlayer(PLAYER2_ID, SESSION_ID, "");
    table.setCurrentGame(gameStatus1);
    whenPlayers(p1, p2);
    when(gameRules.getObservableStatus(gameStatus1, getContextFor(p1, false, table.getIncrement())))
        .thenReturn(new PrintlnStatus());
    when(gameRules.getObservableStatus(gameStatus1, getContextFor(p2, true, table.getIncrement())))
        .thenReturn(new PrintlnStatus());
    final com.yazino.game.api.ExecutionResult result =
        new com.yazino.game.api.ExecutionResult.Builder(gameRules, gameStatus1)
            .scheduledEvents(emptyEvents)
            .build();
    when(gameRules.execute(
            isA(com.yazino.game.api.ExecutionContext.class), eq(command.toCommand(PLAYER_NAME))))
        .thenReturn(result);
    final List<HostDocument> hostDocuments = executeCommand();

    // table.lastGameChanges?
    assertThat(hostDocuments.size(), is(equalTo(2)));
    assertThat(
        (GameStatusHostDocument) hostDocuments.get(0), Matchers.isA(GameStatusHostDocument.class));
    assertThat(
        (GameStatusHostDocument) hostDocuments.get(1), Matchers.isA(GameStatusHostDocument.class));
  }
 @Test
 public void testGetStatusSendsStatusToPlayer() {
   whenGameStart();
   command =
       new CommandWrapper(TABLE_ID, GAME_ID, A_PLAYER.getId(), SESSION_ID, "InitialGetStatus");
   command.setRequestId(UUID);
   final List<HostDocument> hostDocuments = executeCommand();
   assertThat(
       (GameStatusHostDocument) hostDocuments.get(0), Matchers.isA(GameStatusHostDocument.class));
 }
 @SuppressWarnings({"ThrowableInstanceNeverThrown"})
 @Test
 public void senderGetsErrorMessageWhenExceptionThrownInGameHost()
     throws com.yazino.game.api.GameException {
   whenGameStart();
   com.yazino.game.api.ParameterisedMessage pm =
       new com.yazino.game.api.ParameterisedMessage("UPS!");
   when(gameRules.execute(
           isA(com.yazino.game.api.ExecutionContext.class), eq(command.toCommand(PLAYER_NAME))))
       .thenThrow(new com.yazino.game.api.GameException(pm));
   final List<HostDocument> hostDocuments = executeCommand();
   assertThat((ErrorHostDocument) hostDocuments.get(1), Matchers.isA(ErrorHostDocument.class));
 }
 @Test
 public void commandsAndStatusChangesGetAudited() throws com.yazino.game.api.GameException {
   whenGameStart();
   whenPlayers();
   final com.yazino.game.api.ExecutionResult result =
       new com.yazino.game.api.ExecutionResult.Builder(gameRules, gameStatus1)
           .scheduledEvents(emptyEvents)
           .build();
   when(gameRules.execute(
           isA(com.yazino.game.api.ExecutionContext.class),
           isA(com.yazino.game.api.Command.class)))
       .thenReturn(result);
   executeCommand();
   verify(auditor).audit(eq(AUDIT_LABEL), eq(command.toCommand(PLAYER_NAME)));
 }
 @SuppressWarnings({"ThrowableInstanceNeverThrown", "ThrowableResultOfMethodCallIgnored"})
 @Test
 public void commandsAndExceptionGetAuditedInCaseOfErrors()
     throws com.yazino.game.api.GameException {
   whenGameStart();
   com.yazino.game.api.GameException exc =
       new com.yazino.game.api.GameException(new com.yazino.game.api.ParameterisedMessage("XYZ"));
   doThrow(exc)
       .when(gameRules)
       .execute(
           isA(com.yazino.game.api.ExecutionContext.class),
           isA(com.yazino.game.api.Command.class));
   executeCommand();
   verify(auditor).audit(AUDIT_LABEL, command.toCommand(PLAYER_NAME));
 }
 private CommandWrapper commandFrom(final BigDecimal playerId) {
   final CommandWrapper commandWrapper =
       new CommandWrapper(
           command.getTableId(),
           command.getGameId(),
           playerId,
           SESSION_ID,
           command.getType(),
           command.getArgs());
   commandWrapper.setRequestId(UUID);
   return commandWrapper;
 }
 @Test
 public void executeAcknowledgement() {
   table.playerAcknowledgesIncrement(A_PLAYER.getId(), 1L);
   table.setIncrement(10L);
   table.setCurrentGame(gameStatus);
   when(gameRules.isAPlayer(gameStatus, A_PLAYER)).thenReturn(true);
   addPlayersToGame(gameStatus, A_PLAYER);
   command =
       new CommandWrapper(
           table.getTableId(),
           table.getGameId(),
           A_PLAYER.getId(),
           SESSION_ID,
           com.yazino.game.api.Command.CommandType.Ack.getCode(),
           "9");
   command.setRequestId(UUID);
   executeCommand();
   assertEquals(9L, table.playerAtTable(A_PLAYER.getId()).getAcknowledgedIncrement());
 }
 @Test
 public void testObserversGetNotified() throws com.yazino.game.api.GameException {
   whenGameStart();
   final com.yazino.game.api.ExecutionResult executionResult =
       new com.yazino.game.api.ExecutionResult.Builder(
               new PrintlnRules(), new GameStatus(new PrintlnStatus()))
           .scheduledEvents(emptyEvents)
           .build();
   when(gameRules.getObservableStatus(gameStatus1, getContextFor(null)))
       .thenReturn(new PrintlnStatus());
   when(gameRules.execute(
           isA(com.yazino.game.api.ExecutionContext.class), eq(command.toCommand(PLAYER_NAME))))
       .thenReturn(executionResult);
   final List<HostDocument> hostDocuments = executeCommand();
   assertThat(
       (GameStatusHostDocument) hostDocuments.get(0), Matchers.isA(GameStatusHostDocument.class));
   assertThat(
       (GameStatusHostDocument) hostDocuments.get(1), Matchers.isA(GameStatusHostDocument.class));
 }
 @Test
 public void testTableGetsNewEvents() throws com.yazino.game.api.GameException {
   whenGameStart();
   whenPlayers();
   List<com.yazino.game.api.ScheduledEvent> events =
       Arrays.asList(
           new com.yazino.game.api.ScheduledEvent(
               100l, 100l, "X", "Y", new HashMap<String, String>(), false),
           new com.yazino.game.api.ScheduledEvent(
               300l, 100l, "Z", "Y", new HashMap<String, String>(), false),
           new com.yazino.game.api.ScheduledEvent(
               200l, 100l, "X", "Z", new HashMap<String, String>(), false));
   final com.yazino.game.api.ExecutionResult result =
       new com.yazino.game.api.ExecutionResult.Builder(gameRules, gameStatus1)
           .scheduledEvents(events)
           .build();
   when(gameRules.execute(
           (com.yazino.game.api.ExecutionContext) anyObject(), eq(command.toCommand(PLAYER_NAME))))
       .thenReturn(result);
   executeCommand();
   assertEquals(3, table.scheduledEventCount());
 }
  @Before
  public void setUp() throws com.yazino.game.api.GameException, WalletServiceException {
    MockitoAnnotations.initMocks(this);

    timeSource = new SettableTimeSource(System.currentTimeMillis());

    command = new CommandWrapper(TABLE_ID, GAME_ID, A_PLAYER.getId(), SESSION_ID, "T");
    command.setRequestId(UUID);
    playerStatisticEventsPublisher = new InMemoryPlayerStatisticEventsPublisher();

    table =
        new Table(
            new com.yazino.game.api.GameType(GAME_TYPE, "Test", Collections.<String>emptySet()),
            BigDecimal.ONE,
            "test",
            true);
    table.setTableId(TABLE_ID);
    table.setTableStatus(TableStatus.open);
    table.setVariationProperties(new HashMap<String, String>());

    when(bufferedGameHostWalletFactory.create(table.getTableId(), command.getRequestId()))
        .thenReturn(bufferedGameHostWallet);
    when(bufferedGameHostWalletFactory.create(table.getTableId()))
        .thenReturn(bufferedGameHostWallet);

    when(auditor.newLabel()).thenReturn(AUDIT_LABEL);
    when(bufferedGameHostWallet.getBalance(Mockito.isA(BigDecimal.class)))
        .thenReturn(BigDecimal.ZERO);

    when(uuidSource.getNewUUID()).thenReturn(NEW_UUID);
    when(auditor.newLabel()).thenReturn(AUDIT_LABEL);
    when(bufferedGameHostWallet.getBalance(Mockito.isA(BigDecimal.class)))
        .thenReturn(ACCOUNT_BALANCE);

    when(gameRules.getGameType()).thenReturn("TEST");

    when(playerRepository.findSummaryByPlayerAndSession(PLAYER_ID, SESSION_ID))
        .thenReturn(
            aPlayerSessionSummary(PLAYER_ID, "Player", PLAYER_ACCOUNT_ID, BigDecimal.valueOf(100)));
    when(playerRepository.findSummaryByPlayerAndSession(PLAYER_ID, null))
        .thenReturn(
            aPlayerSessionSummary(PLAYER_ID, "Player", PLAYER_ACCOUNT_ID, BigDecimal.valueOf(100)));
    when(playerRepository.findSummaryByPlayerAndSession(PLAYER1_ID, null))
        .thenReturn(
            aPlayerSessionSummary(
                PLAYER1_ID, "Player1", PLAYER1_ACCOUNT_ID, BigDecimal.valueOf(200)));
    when(playerRepository.findSummaryByPlayerAndSession(PLAYER2_ID, null))
        .thenReturn(
            aPlayerSessionSummary(
                PLAYER2_ID, "Player2", PLAYER2_ACCOUNT_ID, BigDecimal.valueOf(300)));

    when(chatRepository.getOrCreateForLocation(TABLE_ID.toPlainString()))
        .thenReturn(new ChatChannel(TABLE_ID.toPlainString()));
  }