Multi-Chess/fh.fd.ci.server/src/test/java/de/fd/fh/server/user/UserServiceTest.java

package de.fd.fh.server.user;

import de.fd.fh.shared.network.messages.ChangeUserRequest;
import de.fd.fh.shared.network.messages.UserRequest;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.mockito.ArgumentCaptor;

import java.util.Observable;
import java.util.Observer;

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

class UserServiceTest implements Observer
{
    private Object event;

    @BeforeEach
    void before()
    {
        event = null;
    }

    @Test
    void given_storedUser_when_changePassword_should_changePassword()
    {
        final User user =
                User.of("testName");
        final ChangeUserRequest request =
                new ChangeUserRequest(null, "newPassword");
        final UserRepository repository = mock(UserRepository.class);
        when(repository.findUserById(any(UserId.class)))
                .thenReturn(user);

        final de.fd.fh.server.user.UserService service = new de.fd.fh.server.user.UserService(repository);
        service.addObserver(this);

        service.changePlayer(UserId.of("12345"), request);

        assertNotNull(event);
    }

    @Test
    void given_storedUser_when_changeUserName_should_renameAndFireEvent()
    {
        final User user =
                User.of("testName");
        final ChangeUserRequest request =
                new ChangeUserRequest("newTestName", null);
        final UserRepository repository = mock(UserRepository.class);
        when(repository.findUserById(any(UserId.class)))
                .thenReturn(user);
        when(repository.findUserByName(any()))
                .thenReturn(null);

        final de.fd.fh.server.user.UserService service = new de.fd.fh.server.user.UserService(repository);
        service.addObserver(this);
        final ArgumentCaptor<User> captor = ArgumentCaptor.forClass(User.class);

        service.changePlayer(UserId.of("12345"), request);

        then(repository).should().findUserById(any(UserId.class));
        then(repository).should().findUserByName(any());
        verify(repository).save(captor.capture());
        then(repository).should().save(any());
        then(repository).shouldHaveNoMoreInteractions();
        assertNotNull(captor.getValue(), "Should be saved");
        assertEquals(captor.getValue().getName(), "newTestName", "User should have new name");
        assertNotNull(event);
    }

    @Test
    void given_storedUser_when_getPlayer_should_returnPlayer()
    {
        final User user =
                User.of("testName");
        final UserRepository repository = mock(UserRepository.class);
        when(repository.findUserById(any(UserId.class)))
                .thenReturn(user);

        final User result = new UserService(repository).getPlayer(UserId.of("12345"));

        assertNotNull(result);
    }

    @Test
    void given_storedUser_when_getSmallPlayer_should_returnSmallPlayer()
    {
        final User user =
                new User(UserId.of("12345"), "testName");
        final UserRepository repository = mock(UserRepository.class);
        when(repository.findUserById(any(UserId.class)))
                .thenReturn(user);

        final UserRequest result = new de.fd.fh.server.user.UserService(repository).getSmallPlayer(UserId.of("12345"));

        assertNotNull(result);
        assertEquals("12345", result.getId(), "Wrong UserId");
        assertEquals("testName", result.getName(), "Wrong Name");

    }

    @Override
    public void update(Observable o, Object arg)
    {
        event = arg;
    }
}