SpringUserFrameworkDemoApp/src/test/java/com/digitalsanctuary/spring/user/service/UserServiceTest.java at 41594608dbef331604e56b19ac663715ba2e5401 · devondragon/SpringUserFrameworkDemoApp · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
package com.digitalsanctuary.spring.user.service;

import static org.mockito.ArgumentMatchers.anyString;
import static org.mockito.Mockito.when;
import java.util.Collections;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import org.springframework.context.ApplicationEventPublisher;
import org.springframework.security.core.session.SessionRegistry;
import org.springframework.security.crypto.password.PasswordEncoder;
import com.digitalsanctuary.spring.user.dto.UserDto;
import com.digitalsanctuary.spring.user.exceptions.UserAlreadyExistException;
import com.digitalsanctuary.spring.user.persistence.model.Role;
import com.digitalsanctuary.spring.user.persistence.model.User;
import com.digitalsanctuary.spring.user.persistence.repository.PasswordHistoryRepository;
import com.digitalsanctuary.spring.user.persistence.repository.PasswordResetTokenRepository;
import com.digitalsanctuary.spring.user.persistence.repository.RoleRepository;
import com.digitalsanctuary.spring.user.persistence.repository.UserRepository;
import com.digitalsanctuary.spring.user.persistence.repository.VerificationTokenRepository;

@ExtendWith(MockitoExtension.class)
public class UserServiceTest {

    private static final String USER_ROLE_NAME = "ROLE_USER";
    @Mock
    private UserRepository userRepository;
    @Mock
    private VerificationTokenRepository tokenRepository;
    @Mock
    private PasswordResetTokenRepository passwordTokenRepository;
    @Mock
    private PasswordEncoder passwordEncoder;
    @Mock
    private RoleRepository roleRepository;
    @Mock
    private SessionRegistry sessionRegistry;
    @Mock
    public UserEmailService userEmailService;
    @Mock
    public UserVerificationService userVerificationService;

    @Mock
    private ApplicationEventPublisher eventPublisher;

    @Mock
    public AuthorityService authorityService;

    @Mock
    private DSUserDetailsService dsUserDetailsService;

    @Mock
    private PasswordHistoryRepository passwordHistoryRepository;

    @Mock
    private SessionInvalidationService sessionInvalidationService;

    private UserService userService;
    private User testUser;
    private UserDto testUserDto;

    @BeforeEach
    void setUp() {
        testUser = new User();
        testUser.setEmail("test@example.com");
        testUser.setFirstName("testFirstName");
        testUser.setLastName("testLastName");
        testUser.setPassword("testPassword");
        testUser.setRoles(Collections.singletonList(new Role("ROLE_USER")));
        testUser.setEnabled(true);

        testUserDto = new UserDto();
        testUserDto.setEmail("test@example.com");
        testUserDto.setFirstName("testFirstName");
        testUserDto.setLastName("testLastName");
        testUserDto.setPassword("testPassword");
        testUserDto.setRole(1);

        userService = new UserService(userRepository, tokenRepository, passwordTokenRepository, passwordEncoder,
                roleRepository, sessionRegistry, userEmailService, userVerificationService, authorityService,
                dsUserDetailsService, eventPublisher, passwordHistoryRepository, sessionInvalidationService);
    }

    @Test
    void registerNewUserAccount_returnsUserWhenUserIsNew() {
        when(passwordEncoder.encode(testUser.getPassword())).thenReturn(testUser.getPassword());
        when(roleRepository.findByName(USER_ROLE_NAME)).thenReturn(new Role(USER_ROLE_NAME));
        when(userRepository.save(testUser)).thenReturn(testUser);
        User saved = userService.registerNewUserAccount(testUserDto);
        Assertions.assertEquals(saved, testUser);
    }

    @Test
    void registerNewUserAccount_throwsExceptionWhenUserExist() {
        when(userRepository.findByEmail(testUser.getEmail())).thenReturn(testUser);
        Assertions.assertThrows(UserAlreadyExistException.class, () -> userService.registerNewUserAccount(testUserDto));
    }

    @Test
    void findByEmail_returnsUserWhenEmailExist() {
        when(userRepository.findByEmail(testUser.getEmail())).thenReturn(testUser);
        User found = userService.findUserByEmail(testUser.getEmail());
        Assertions.assertEquals(found, testUser);
    }

    @Test
    void checkIfValidOldPassword_returnTrueIfValid() {
        when(passwordEncoder.matches(anyString(), anyString())).thenReturn(true);
        Assertions.assertTrue(userService.checkIfValidOldPassword(testUser, testUser.getPassword()));
    }

}