CIiP-WS-2020-2021-Projektarbeit_Multi-Chess/fh.fd.ci.server/src/test/java/de/fd/fh/server/game/GameServiceTest.java

package de.fd.fh.server.game;

import de.fd.fh.server.user.UserId;
import dev.morphia.Key;
import org.junit.jupiter.api.Test;
import org.mockito.ArgumentCaptor;

import java.util.List;
import java.util.Set;

import static org.junit.jupiter.api.Assertions.*;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.BDDMockito.then;
import static org.mockito.Mockito.*;

class GameServiceTest
{
    @Test
    void testCreateGame()
    {
        final GameRepository repository = when(mock(GameRepository.class).save(any()))
                .thenReturn(new Key<>(Game.class, "testCollection", GameId.of("98765")))
                .getMock();

        final Game game = new Game();

        final GameId result = new GameService(repository).createGame(game);

        assertNotNull(result);
        assertEquals("98765", result.getIdentifier());
    }

    @Test
    void given_twoUserIds_when_initGame_should_initGame()
    {
        final UserId blackPlayer = UserId.of("12345");
        final UserId whitePlayer = UserId.of("98765");

        final GameRepository repository = when(mock(GameRepository.class).save(any()))
                .thenReturn(new Key<>(Game.class, "testCollection", GameId.of("4242")))
                .getMock();

        final ArgumentCaptor<Game> captor = ArgumentCaptor.forClass(Game.class);

        final GameId result = new GameService(repository).createGame(blackPlayer, whitePlayer);

        verify(repository).save(captor.capture());

        assertEquals("4242", result.getIdentifier());

        assertNotNull(captor.getValue());

        final Game savedGame = captor.getValue();

        assertEquals("12345", savedGame.getBlackPlayer().getIdentifier());
        assertEquals("98765", savedGame.getWhitePlayer().getIdentifier());
        assertEquals("98765", savedGame.getCurrentPlayer().getIdentifier());
        assertEquals(64, savedGame.getFields().size());

        final Set<Field> fields = savedGame.getFields();

        fields.forEach(field -> {

            final Field.Color expected = (field.getX() + field.getY()) % 2 != 1 ? Field.Color.WHITE : Field.Color.BLACK;

            if (field.getX() == 0 || field.getX() == 1 || field.getX() == 6 || field.getX() == 7)
            {
                assertNotNull(field.getFigure());
            }
            else
            {
                assertNull(field.getFigure());
            }

            assertEquals(expected, field.getColor());
        });

        then(repository).should().save(any(Game.class));
        then(repository).shouldHaveNoMoreInteractions();
    }

    @Test
    void given_storedGame_when_findGameById_should_returnGame()
    {
        final GameRepository repository = when(mock(GameRepository.class).findByGameId(any(GameId.class)))
                .thenReturn(new Game(null, null, null, null, null, null))
                .getMock();

        final Game result = new GameService(repository).findGameById(GameId.of("12345"));

        assertNotNull(result);
    }

    @Test
    void given_storedGames_when_findGamesOfUser_should_returnSetOfGames()
    {
        final GameRepository repository = when(mock(GameRepository.class).findRunningGamesOfPlayer(any(UserId.class)))
                .thenReturn(List.of(
                        new Game(GameId.random(), UserId.of("12345"), UserId.random(), null, null, null),
                        new Game(GameId.random(), UserId.random(), UserId.of("12345"), null, null, null)))
                .getMock();

        final List<Game> result = new GameService(repository).findRunningGamesOfUser(UserId.of("12345"));

        assertEquals(2, result.size());
    }
}