コード例 #1
0
 @Test
 public void testProcessTransactionResultCorrectlyCallsAuditOnSuccessWithNonNullExecutionResult()
     throws com.yazino.game.api.GameException {
   final String auditLabel = "test424243542354";
   gameStatus = mock(com.yazino.game.api.GameStatus.class);
   when(gameRules.canBeClosed(gameStatus)).thenReturn(false);
   when(gameRules.isComplete(gameStatus)).thenReturn(false);
   whenPlayers();
   when(gameRules.getPlayerInformation(gameStatus))
       .thenReturn(Collections.<com.yazino.game.api.PlayerAtTableInformation>emptyList());
   when(gameRules.getNumberOfSeatsTaken(gameStatus)).thenReturn(0);
   table.setCurrentGame(gameStatus);
   table.setGameId(GAME_ID);
   final com.yazino.game.api.TransactionResult txResult =
       new com.yazino.game.api.TransactionResult("foo", true, null, null, null, null);
   final com.yazino.game.api.ExecutionResult executionResult =
       new com.yazino.game.api.ExecutionResult.Builder(gameRules, gameStatus).build();
   when(gameRules.processTransactionResult(
           isA(com.yazino.game.api.ExecutionContext.class), eq(txResult)))
       .thenReturn(executionResult);
   auditor = mock(Auditor.class);
   when(auditor.newLabel()).thenReturn(auditLabel);
   host = gameHost(new InMemoryGameRepository(gameRules));
   host.processTransactionResult(table, GAME_ID, txResult);
 }
コード例 #2
0
 @Test
 public void forceNewGameWillRestartTableAndStartNewGame() {
   Map<BigDecimal, BigDecimal> playerIdToAccountIdOverrides = new HashMap<>();
   playerIdToAccountIdOverrides.put(PLAYER_ID, BigDecimal.valueOf(202020));
   com.yazino.game.api.GameStatus status = new GameStatus(new PrintlnStatus());
   com.yazino.game.api.ExecutionResult result =
       new com.yazino.game.api.ExecutionResult.Builder(gameRules, status).build();
   when(gameRules.startNewGame(isA(com.yazino.game.api.GameCreationContext.class)))
       .thenReturn(result);
   when(auditor.newLabel()).thenReturn("X");
   host = gameHost(new InMemoryGameRepository(gameRules));
   table.setTableStatus(TableStatus.closed);
   table.setCurrentGame(null);
   Collection<com.yazino.game.api.PlayerAtTableInformation> playersAtTable =
       Arrays.asList(
           new com.yazino.game.api.PlayerAtTableInformation(
               new com.yazino.game.api.GamePlayer(PLAYER1_ID, null, "One"),
               Collections.<String, String>emptyMap()),
           new com.yazino.game.api.PlayerAtTableInformation(
               new com.yazino.game.api.GamePlayer(PLAYER2_ID, null, "Two"),
               Collections.<String, String>emptyMap()));
   host.forceNewGame(table, playersAtTable, playerIdToAccountIdOverrides);
   ArgumentCaptor<com.yazino.game.api.GameCreationContext> contextCaptor =
       ArgumentCaptor.forClass(com.yazino.game.api.GameCreationContext.class);
   verify(gameRules).startNewGame(contextCaptor.capture());
   assertEquals(TableStatus.open, table.getTableStatus());
   assertEquals(status, table.getCurrentGame());
   assertEquals(playersAtTable, contextCaptor.getValue().getPlayersAtTableInformation());
 }
コード例 #3
0
 @Test
 public void testProcessTransactionResultCorrectlyCallsAuditOnSuccessWithNullExecutionResult() {
   final String auditLabel = "test424542542354";
   gameStatus = mock(com.yazino.game.api.GameStatus.class);
   when(gameRules.isComplete(gameStatus)).thenReturn(false);
   table.setCurrentGame(gameStatus);
   table.setGameId(GAME_ID);
   final com.yazino.game.api.TransactionResult txResult =
       new com.yazino.game.api.TransactionResult("foo", true, null, null, null, null);
   auditor = mock(Auditor.class);
   when(auditor.newLabel()).thenReturn(auditLabel);
   host = gameHost(new InMemoryGameRepository(gameRules));
   host.processTransactionResult(table, GAME_ID, txResult);
 }
コード例 #4
0
 @Test
 public void testProcessTransactionResultIsNotProcessedForCompleteGame() {
   final GameRepository mockGameRepository = mock(GameRepository.class);
   when(mockGameRepository.getGameRules(GAME_TYPE)).thenReturn(gameRules);
   gameStatus = mock(com.yazino.game.api.GameStatus.class);
   when(gameRules.isComplete(gameStatus)).thenReturn(true);
   table.setCurrentGame(gameStatus);
   table.setGameId(GAME_ID);
   final com.yazino.game.api.TransactionResult txResult =
       new com.yazino.game.api.TransactionResult("foo", true, null, null, null, null);
   host = gameHost(mockGameRepository);
   host.processTransactionResult(table, GAME_ID, txResult);
   verifyNoMoreInteractions(documentDispatcher);
 }
コード例 #5
0
 @Test
 public void testProcessTransactionResultIsOnlyExecutedForTheCurrentGame() {
   final GameRepository mockGameRepository = mock(GameRepository.class);
   when(mockGameRepository.getGameRules(GAME_TYPE)).thenReturn(gameRules);
   final long differentGameId = GAME_ID + 6;
   gameStatus = mock(com.yazino.game.api.GameStatus.class);
   when(gameRules.isComplete(gameStatus)).thenReturn(false);
   table.setCurrentGame(gameStatus);
   table.setGameId(GAME_ID);
   final com.yazino.game.api.TransactionResult txResult =
       new com.yazino.game.api.TransactionResult("foo", true, null, null, null, null);
   host = gameHost(mockGameRepository);
   host.processTransactionResult(table, differentGameId, txResult);
   verifyNoMoreInteractions(locationService);
 }
コード例 #6
0
 @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));
 }
コード例 #7
0
  @Test
  public void testProcessTransactionResultUpdatesCachedBalance() {
    BigDecimal ORIGINAL_BALANCE = BigDecimal.ONE;
    BigDecimal NEW_BALANCE = BigDecimal.TEN;
    table.setCurrentGame(gameStatus);
    table.setGameId(GAME_ID);
    com.yazino.game.api.GamePlayer player =
        new com.yazino.game.api.GamePlayer(PLAYER1_ID, SESSION_ID, "");
    addPlayersToGame(gameStatus, player);
    table.playerWithAccountId(PLAYER1_ACCOUNT_ID).setCachedBalance(ORIGINAL_BALANCE);
    final com.yazino.game.api.TransactionResult txResult =
        new com.yazino.game.api.TransactionResult(
            "foo", true, null, PLAYER1_ACCOUNT_ID, NEW_BALANCE, null);
    host = gameHost(new InMemoryGameRepository(gameRules));

    // exercise SUT
    host.processTransactionResult(table, GAME_ID, txResult);

    // verify
    assertEquals(NEW_BALANCE, table.playerWithAccountId(PLAYER1_ACCOUNT_ID).getCachedBalance());
  }
コード例 #8
0
 @SuppressWarnings({"ThrowableResultOfMethodCallIgnored", "ThrowableInstanceNeverThrown"})
 @Test
 public void testProcessTransactionResultCorrectlyCallsAuditOnFailure()
     throws com.yazino.game.api.GameException {
   final String auditLabel = "test42454254345345";
   gameStatus = mock(com.yazino.game.api.GameStatus.class);
   when(gameRules.isComplete(gameStatus)).thenReturn(false);
   table.setCurrentGame(gameStatus);
   table.setGameId(GAME_ID);
   final com.yazino.game.api.TransactionResult txResult =
       new com.yazino.game.api.TransactionResult("foo", true, null, null, null, null);
   final com.yazino.game.api.GameException thrownException =
       new com.yazino.game.api.GameException(
           new com.yazino.game.api.ParameterisedMessage("test.mock.error"));
   when(gameRules.processTransactionResult(
           isA(com.yazino.game.api.ExecutionContext.class), eq(txResult)))
       .thenThrow(thrownException);
   auditor = mock(Auditor.class);
   when(auditor.newLabel()).thenReturn(auditLabel);
   host = gameHost(new InMemoryGameRepository(gameRules));
   host.processTransactionResult(table, GAME_ID, txResult);
   verify(auditor, times(1)).newLabel();
 }
コード例 #9
0
  private GameHost gameHost(final GameRepository mockGameRepository) {
    final DestinationFactory destinationFactory = new DestinationFactory();

    GameInitialiser gameInitialiser = new GameInitialiser();
    gameInitialiser.setEventPreInitialisationProcessors(
        Arrays.asList(
            (EventPreprocessor) new TableClosedPreprocessor(destinationFactory),
            new GameDisabledPreprocessor(mockGameRepository, destinationFactory)));
    gameInitialiser.setCommandPreInitialisationProcessors(
        Arrays.asList(
            new TableClosedPreprocessor(destinationFactory),
            new TournamentPlayerValidator(destinationFactory),
            new GameDisabledPreprocessor(mockGameRepository, destinationFactory)));
    gameInitialiser.setPostInitialisationProcessors(
        Arrays.asList(
            new PlayerNotificationPostProcessor(destinationFactory, mockGameRepository),
            new ObserverNotificationPostprocessor(mockGameRepository, destinationFactory),
            new NotifyLocationChangesPostprocessor(
                mockGameRepository, playerRepository, chatRepository, locationService),
            new TableUpdatePostprocessor(mockGameRepository, timeSource)));

    GameEventExecutor eventExecutor =
        new GameEventExecutor(
            mockGameRepository, auditor, bufferedGameHostWalletFactory, novomaticRequestService);
    eventExecutor.setGameInitialiser(gameInitialiser);
    GameCommandExecutor commandExecutor =
        new GameCommandExecutor(
            mockGameRepository,
            auditor,
            bufferedGameHostWalletFactory,
            novomaticRequestService,
            playerRepository,
            destinationFactory);
    commandExecutor.setGameInitialiser(gameInitialiser);
    commandExecutor.setUuidSource(uuidSource);

    final GameHost gameHost =
        new GameHost(
            auditor,
            mockGameRepository,
            destinationFactory,
            playerRepository,
            bufferedGameHostWalletFactory,
            novomaticRequestService,
            uuidSource,
            eventExecutor,
            commandExecutor,
            gameInitialiser);

    gameHost.getEventExecutor().setGameInitialiser(gameInitialiser);
    gameHost.getCommandExecutor().setGameInitialiser(gameInitialiser);

    // this setup is a nasty side-effect of splitting initialisation of these classes out of the
    // game host.
    // On the upside, it means the GH tests can in future just test the GH itself.

    gameHost
        .getEventExecutor()
        .setPreExecutionProcessors(
            Arrays.asList(
                new AuditPreprocessor(auditor),
                new TableReadyEventPreprocessor(mockGameRepository),
                new NopEventPreprocessor(),
                new EventStillValidPreprocessor()));
    gameHost
        .getEventExecutor()
        .setPostExecutionProcessors(
            Arrays.asList(
                new GameCompletePostprocessor(mockGameRepository, timeSource),
                new NotifyLocationChangesPostprocessor(
                    mockGameRepository, playerRepository, chatRepository, locationService),
                new PlayerNotificationPostProcessor(destinationFactory, mockGameRepository),
                new ObserverNotificationPostprocessor(mockGameRepository, destinationFactory),
                new GameDisabledPostprocessor(mockGameRepository, destinationFactory),
                new TableUpdatePostprocessor(mockGameRepository, timeSource),
                new GameXPPublishingPostProcessor(playerStatisticEventsPublisher),
                new TableAuditPostprocessor(auditor, gameCompletePublisher, mockGameRepository)));

    gameHost
        .getCommandExecutor()
        .setPreExecutionProcessors(
            Arrays.asList(
                new AuditPreprocessor(auditor),
                new TableClosingPreprocessor(destinationFactory),
                new InitialGetStatusPreprocessor(auditor, destinationFactory),
                new AcknowledgementPreprocessor()));

    gameHost
        .getCommandExecutor()
        .setPostExecutionProcessors(
            Arrays.asList(
                new GameCompletePostprocessor(mockGameRepository, timeSource),
                new NotifyLocationChangesPostprocessor(
                    mockGameRepository, playerRepository, chatRepository, locationService),
                new PlayerNotificationPostProcessor(destinationFactory, mockGameRepository),
                new ObserverNotificationPostprocessor(mockGameRepository, destinationFactory),
                new GameDisabledPostprocessor(mockGameRepository, destinationFactory),
                new TableUpdatePostprocessor(mockGameRepository, timeSource),
                new GameXPPublishingPostProcessor(playerStatisticEventsPublisher),
                new TableAuditPostprocessor(auditor, gameCompletePublisher, mockGameRepository)));

    gameHost.setPlayerRemovalProcessors(
        Arrays.asList(
            (PlayerRemovalProcessor)
                new NotifyLocationChangesPostprocessor(
                    mockGameRepository, playerRepository, chatRepository, locationService)));

    return gameHost;
  }
コード例 #10
0
 private List<HostDocument> executeCommand() {
   host = gameHost(new InMemoryGameRepository(gameRules));
   return host.execute(table, command);
 }