Fixes Minor Edge Cases and Improves UserService Testing

src/main/java/com/hideyoshi/backendportfolio/base/user/service/UserServiceImpl.java

@@ -1,5 +1,6 @@
 package com.hideyoshi.backendportfolio.base.user.service;
 
+import com.hideyoshi.backendportfolio.base.user.entity.Provider;
 import com.hideyoshi.backendportfolio.base.user.entity.Role;
 import com.hideyoshi.backendportfolio.base.user.entity.User;
 import com.hideyoshi.backendportfolio.base.user.model.UserDTO;
@@ -34,19 +35,13 @@ public class UserServiceImpl implements UserService {
             throw new BadRequestException(String.format("User %s already exists. Try another UserName.", userOnDB.getUsername()));
         });
 
+        user.setPassword(this.validatePassword(user));
+
+        user.setRoles(this.validateRoles(user.getRoles()));
+
         log.info(String.format("Saving to the database user of name: %s", user.getName()));
-
-        if (Objects.nonNull(user.getPassword())) {
-            user.setPassword(passwordEncoder.encode(user.getPassword()));
-        } else {
-            user.setPassword("");
-        }
         UserDTO userSaved = new UserDTO(userRepo.save(user.toEntity()));
 
-        if (!userSaved.getRoles().contains(Role.USER)) {
-            userSaved.getRoles().add(Role.USER);
-        }
-
         return userSaved;
     }
 
@@ -147,4 +142,31 @@ public class UserServiceImpl implements UserService {
     public UserDetails loadUserByUsername(String username) {
         return this.getUser(username);
     }
+
+    private String validatePassword(UserDTO user) {
+        String password = null;
+        if (Objects.nonNull(user.getPassword())) {
+            password = passwordEncoder.encode(user.getPassword());
+        } else if (!user.getProvider().equals(Provider.LOCAL)) {
+            password = "";
+        }
+
+        if (Objects.isNull(password)) {
+            throw new BadRequestException("Password cannot be empty.");
+        }
+
+        return password;
+    }
+
+    private List<Role> validateRoles(List<Role> roles) {
+        if (Objects.isNull(roles)) {
+            roles = List.of(Role.USER);
+        }
+
+        if (!roles.contains(Role.USER)) {
+            roles.add(Role.USER);
+        }
+
+        return roles;
+    }
 }

src/test/java/com/hideyoshi/backendportfolio/base/user/service/UserServiceImplTest.java

@@ -38,12 +38,10 @@ class UserServiceImplTest {
     @Mock
     private UserRepository userRepository;
 
-    private PasswordEncoder passwordEncoder;
-
 
     @BeforeEach
     void setUp() {
-        this.passwordEncoder = new BCryptPasswordEncoder();
+        PasswordEncoder passwordEncoder = new BCryptPasswordEncoder();
         this.underTest = new UserServiceImpl(userRepository, passwordEncoder);
     }
 
@@ -58,8 +56,10 @@ class UserServiceImplTest {
 
         // Given
         UserDTO user = this.createUser();
+
         // When
         UserDTO userSaved = this.underTest.saveUser(user);
+
         //Then
         ArgumentCaptor<User> userArgumentCaptor = ArgumentCaptor.forClass(User.class);
 
@@ -68,6 +68,30 @@ class UserServiceImplTest {
         assertThat(userSaved).isInstanceOf(UserDTO.class);
     }
 
+    @Test
+    void canSaveOAuthUser() {
+
+            BDDMockito.when(userRepository.findByUsername(ArgumentMatchers.any(String.class)))
+                    .thenReturn(Optional.ofNullable(null));
+
+            BDDMockito.when(userRepository.save(ArgumentMatchers.any(User.class)))
+                    .thenReturn(createOAuthUser().toEntity());
+
+            // Given
+            UserDTO user = this.createOAuthUser();
+
+            // When
+            UserDTO userSaved = this.underTest.saveUser(user);
+
+            //Then
+            ArgumentCaptor<User> userArgumentCaptor = ArgumentCaptor.forClass(User.class);
+
+            verify(userRepository).save(userArgumentCaptor.capture());
+            assertThat(userArgumentCaptor.getValue()).isEqualTo(user.toEntity());
+            assertThat(userArgumentCaptor.getValue().getPassword()).isEmpty();
+            assertThat(userSaved).isInstanceOf(UserDTO.class);
+    }
+
     @Test
     void cannotSaveUser() {
 
@@ -77,7 +101,6 @@ class UserServiceImplTest {
 
         // Given
         UserDTO user = this.createUser();
-        // When
         //Then
         assertThrows(
                 BadRequestException.class,
@@ -88,6 +111,29 @@ class UserServiceImplTest {
         );
     }
 
+    @Test
+    void cannotSaveUserWithEmptyPassword() {
+
+        BDDMockito.when(userRepository.findByUsername(ArgumentMatchers.any(String.class)))
+                .thenReturn(Optional.ofNullable(null));
+
+
+        // Given
+        UserDTO user = this.createUser();
+
+        // When
+        user.setPassword(null);
+
+        //Then
+        assertThrows(
+                BadRequestException.class,
+                () -> {
+                    this.underTest.saveUser(user);
+                },
+                "Password cannot be empty."
+        );
+    }
+
     @Test
     void canAlterUser() {
         BDDMockito.when(userRepository.findById(ArgumentMatchers.any(Long.class)))
@@ -125,6 +171,7 @@ class UserServiceImplTest {
     @Test
     void canAddRoleToUser() {
         UserDTO user = this.createUser();
+        user.setRoles(List.of());
 
         BDDMockito.when(userRepository.findById(ArgumentMatchers.any(Long.class)))
                 .thenReturn(Optional.ofNullable(user.toEntity()));
@@ -347,6 +394,40 @@ class UserServiceImplTest {
         );
     }
 
+    @Test
+    void canDeleteUser() {
+        UserDTO user = this.createUser();
+
+        BDDMockito.when(userRepository.findById(ArgumentMatchers.any(Long.class)))
+                .thenReturn(Optional.ofNullable(user.toEntity()));
+
+        // When
+        this.underTest.deleteUser(user.getId());
+        // Then
+        ArgumentCaptor<User> argumentCaptor = ArgumentCaptor.forClass(User.class);
+
+        verify(userRepository).delete(argumentCaptor.capture());
+        assertThat(argumentCaptor.getValue().getId()).isEqualTo(user.getId());
+    }
+
+    @Test
+    void cannotDeleteUser() {
+        UserDTO user = this.createUser();
+
+        BDDMockito.when(userRepository.findById(ArgumentMatchers.any(Long.class)))
+                .thenReturn(Optional.ofNullable(null));
+
+        // When
+        // Then
+        assertThrows(
+                BadRequestException.class,
+                () -> {
+                    this.underTest.deleteUser(user.getId());
+                },
+                "User doesn't exist."
+        );
+    }
+
     private UserDTO createUser() {
         return UserDTO.builder()
                 .id(1L)
@@ -355,8 +436,16 @@ class UserServiceImplTest {
                 .username("Superman")
                 .password("password")
                 .provider(Provider.LOCAL)
-                .roles(List.of(Role.USER))
                 .build();
     }
 
+    private UserDTO createOAuthUser() {
+        return UserDTO.builder()
+                .id(1L)
+                .name("Clark Kent")
+                .email("superman@gmail.com")
+                .username("Superman")
+                .provider(Provider.GOOGLE)
+                .build();
+    }
 }