fixed return value of register endpoint and added test

src/main/java/ntnu/idatt2016/v233/SmartMat/controller/UserController.java

@@ -6,6 +6,8 @@ import ntnu.idatt2016.v233.SmartMat.dto.request.RegisterUserRequest;
 import ntnu.idatt2016.v233.SmartMat.dto.enums.Authority;
 import ntnu.idatt2016.v233.SmartMat.entity.user.User;
 import ntnu.idatt2016.v233.SmartMat.service.user.UserService;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
 import org.springframework.security.crypto.password.PasswordEncoder;
 import org.springframework.web.bind.annotation.PostMapping;
 import org.springframework.web.bind.annotation.RequestBody;
@@ -38,7 +40,7 @@ public class UserController {
      * @param user The user to be registered.
      */
     @PostMapping("/register")
-    public void register(@RequestBody RegisterUserRequest user) {
+    public ResponseEntity<User> register(@RequestBody RegisterUserRequest user) {
 
         if(user.username() == null || user.username().trim().isEmpty() || user.username().length() > 50 ||
                 user.password() == null || user.password().trim().isEmpty() || user.password().length() > 50 ||
@@ -46,11 +48,13 @@ public class UserController {
                 user.firstName() == null || user.firstName().trim().isEmpty() || user.firstName().length() > 50 ||
                 user.lastName() == null || user.lastName().trim().isEmpty() || user.lastName().length() > 50 ||
                 user.birthDate() == null) {
-            return;
+            return ResponseEntity.badRequest()
+                    .build();
         }
 
-        if(userService.getUserFromUsername(user.username()).isPresent()) {
-            return;
+        if(userService.getUserFromUsername(user.username()).isPresent() ||
+                userService.getUserFromEmail(user.email()).isPresent()) {
+            return ResponseEntity.status(HttpStatus.CONFLICT).build();
         }
 
         User newUser = User.builder()
@@ -64,7 +68,9 @@ public class UserController {
                 .build();
 
         userService.saveUser(newUser);
+        newUser.setPassword(null);
+        return ResponseEntity.ok(newUser);
     }
 
 
-}
+}
\ No newline at end of file

src/main/java/ntnu/idatt2016/v233/SmartMat/repository/UserRepository.java

@@ -10,8 +10,8 @@ import java.util.Optional;
  * uses mysql from server when ran
  * uses h2 in memory database when testing
  * @author birk
- * @version 1.0
- * @since 05.04.2023
+ * @version 1.1
+ * @since 20.04.2023
  */
 public interface UserRepository extends JpaRepository<User, Long>{
 
@@ -23,4 +23,10 @@ public interface UserRepository extends JpaRepository<User, Long>{
     Optional<User> findByUsername(String username);
 
 
+    /**
+     * gets user from email out of database
+     * @param email email of user
+     * @return user
+     */
+    Optional<User> findByEmail(String email);
 }

src/main/java/ntnu/idatt2016/v233/SmartMat/service/user/UserService.java

@@ -12,8 +12,8 @@ import java.util.Optional;
 /**
  * UserService is a class that implements the UserDetailsService interface.
  * @author Birk
- * @version 1.0
- * @since 05.04.2023
+ * @version 1.1
+ * @since 20.04.2023
  */
 @Service
 @AllArgsConstructor
@@ -89,4 +89,12 @@ public class UserService {
         userRepository.delete(user);
     }
 
+    /**
+     * gets user from email out of database
+     * @param email email of user
+     * @return user
+     */
+    public Optional<User> getUserFromEmail(String email) {
+        return userRepository.findByEmail(email);
+    }
 }

src/test/java/ntnu/idatt2016/v233/SmartMat/repository/UserRepositoryTest.java

@@ -2,9 +2,11 @@ package ntnu.idatt2016.v233.SmartMat.repository;
 
 import ntnu.idatt2016.v233.SmartMat.dto.enums.Authority;
 import ntnu.idatt2016.v233.SmartMat.entity.user.User;
+import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.boot.test.autoconfigure.orm.jpa.DataJpaTest;
+import org.springframework.boot.test.autoconfigure.orm.jpa.TestEntityManager;
 
 import java.sql.Date;
 import java.util.List;
@@ -18,9 +20,14 @@ public class UserRepositoryTest {
     @Autowired
     private UserRepository userRepository;
 
-    @Test
-    void testSaveUser() {
-        User user = User.builder()
+    @Autowired
+    private TestEntityManager entityManager;
+
+    private User user;
+
+    @BeforeEach
+    public void setUp() {
+        user = User.builder()
                 .username("testuser")
                 .password("password")
                 .enabled(true)
@@ -30,6 +37,21 @@ public class UserRepositoryTest {
                 .dateOfBirth(Date.valueOf("1990-01-01"))
                 .authority(Authority.USER)
                 .build();
+        entityManager.persist(user);
+    }
+
+    @Test
+    void testSaveUser() {
+        User user = User.builder()
+                .username("testuserTESTUSER")
+                .password("passwordTEST")
+                .enabled(true)
+                .email("testuser@example.no")
+                .firstName("TestUSERNAME")
+                .lastName("UserTEST")
+                .dateOfBirth(Date.valueOf("1989-01-01"))
+                .authority(Authority.USER)
+                .build();
         userRepository.save(user);
 
         Optional<User> retrievedUser = userRepository.findByUsername(user.getUsername());
@@ -48,14 +70,6 @@ public class UserRepositoryTest {
 
     @Test
     public void findAllTest() {
-        User user1 = new User();
-        user1.setUsername("testuser1");
-        user1.setPassword("password1");
-        user1.setEnabled(true);
-        user1.setEmail("testuser1@example.com");
-        user1.setFirstName("Test1");
-        user1.setLastName("User1");
-        userRepository.save(user1);
         User user2 = new User();
         user2.setUsername("testuser2");
         user2.setPassword("password2");
@@ -66,7 +80,6 @@ public class UserRepositoryTest {
         userRepository.save(user2);
         List<User> users = userRepository.findAll();
         assertEquals(2, users.size());
-        assertEquals(user1.getUsername(), users.get(0).getUsername());
         assertEquals(user2.getUsername(), users.get(1).getUsername());
     }
 
@@ -87,19 +100,6 @@ public class UserRepositoryTest {
 
     @Test
     void testOverwriteUser() {
-        // Create a new user and save it to the database
-        User user = User.builder()
-                .username("testuser")
-                .password("password")
-                .enabled(true)
-                .email("testuser@example.com")
-                .firstName("Test")
-                .lastName("User")
-                .dateOfBirth(Date.valueOf("1990-01-01"))
-                .authority(Authority.USER)
-                .build();
-        userRepository.save(user);
-
         // Modify the user's details and save it again
         User modifiedUser = User.builder()
                 .username("testuser")
@@ -128,4 +128,16 @@ public class UserRepositoryTest {
         assertFalse(userRepository.findByUsername(user.getUsername()).isPresent());
     }
 
+
+    @Test
+    void testFindByUsername() {
+        Optional<User> tempuser = userRepository.findByUsername("testuser");
+
+        assertTrue(tempuser.isPresent());
+        assertEquals("testuser", tempuser.get().getUsername());
+        assertEquals("password", tempuser.get().getPassword());
+        assertTrue(tempuser.get().isEnabled());
+
+    }
+
 }

src/test/java/ntnu/idatt2016/v233/SmartMat/service/user/UserServiceTest.java

+package ntnu.idatt2016.v233.SmartMat.service.user;
+
+
+import ntnu.idatt2016.v233.SmartMat.dto.enums.Authority;
+import ntnu.idatt2016.v233.SmartMat.entity.user.User;
+import ntnu.idatt2016.v233.SmartMat.repository.UserRepository;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.junit.jupiter.MockitoExtension;
+import org.springframework.security.core.userdetails.UsernameNotFoundException;
+
+import java.sql.Date;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Optional;
+
+import static org.junit.jupiter.api.Assertions.*;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.*;
+
+@ExtendWith(MockitoExtension.class)
+public class UserServiceTest {
+
+    @Mock
+    private UserRepository userRepository;
+
+    @InjectMocks
+    private UserService userService;
+
+    @Test
+    public void getUserFromUsername_returnsUser_whenUserExists() {
+        // Arrange
+        User user = User.builder()
+                .username("testuser")
+                .password("password")
+                .enabled(true)
+                .email("testuser@example.com")
+                .firstName("Test")
+                .lastName("User")
+                .dateOfBirth(Date.valueOf("1990-01-01"))
+                .authority(Authority.USER)
+                .build();
+        when(userRepository.findByUsername(user.getUsername())).thenReturn(Optional.of(user));
+
+        // Act
+        Optional<User> result = userService.getUserFromUsername(user.getUsername());
+
+        // Assert
+        assertTrue(result.isPresent());
+        assertEquals(user, result.get());
+        verify(userRepository, times(1)).findByUsername(user.getUsername());
+    }
+
+    @Test
+    public void getUserFromUsername_returnsEmptyOptional_whenUserDoesNotExist() {
+        // Arrange
+        when(userRepository.findByUsername(any())).thenReturn(Optional.empty());
+
+        // Act
+        Optional<User> result = userService.getUserFromUsername("nonexistentuser");
+
+        // Assert
+        assertFalse(result.isPresent());
+        verify(userRepository, times(1)).findByUsername("nonexistentuser");
+    }
+
+    @Test
+    public void getUsers_returnsListOfUsers_whenUsersExist() {
+        // Arrange
+        List<User> users = new ArrayList<>();
+        users.add(User.builder().username("test1").build());
+        users.add(User.builder().username("test2").build());
+        when(userRepository.findAll()).thenReturn(users);
+
+        // Act
+        List<User> result = userService.getUsers();
+
+        // Assert
+        assertEquals(users, result);
+        verify(userRepository, times(1)).findAll();
+    }
+
+    @Test
+    public void updateUser_returnsUser_whenUserExists() {
+        // Arrange
+        User user = User.builder()
+                .username("testuser")
+                .password("password")
+                .enabled(true)
+                .email("testuser@example.com")
+                .firstName("Test")
+                .lastName("User")
+                .dateOfBirth(Date.valueOf("1990-01-01"))
+                .authority(Authority.USER)
+                .build();
+
+        when(userRepository.findByUsername(user.getUsername())).thenReturn(Optional.of(user));
+        when(userRepository.save(user)).thenReturn(user);
+
+        // Act
+        User result = userService.updateUser(user);
+
+        // Assert
+        assertEquals(user, result);
+        verify(userRepository, times(1)).findByUsername(user.getUsername());
+        verify(userRepository, times(1)).save(user);
+    }
+
+    @Test
+    public void updateUser_throwsUsernameNotFoundException_whenUserDoesNotExist() {
+        // Arrange
+        User user = User.builder()
+                .username("testuser")
+                .password("password")
+                .enabled(true)
+                .email("testuser@example.com")
+                .firstName("Test")
+                .lastName("User")
+                .dateOfBirth(Date.valueOf("1990-01-01"))
+                .authority(Authority.USER)
+                .build();
+
+        when(userRepository.findByUsername(user.getUsername())).thenReturn(Optional.empty());
+
+        // Act & Assert
+        assertThrows(UsernameNotFoundException.class, () -> userService.updateUser(user));
+        verify(userRepository, times(1)).findByUsername(user.getUsername());
+        verify(userRepository, times(0)).save(user);
+    }
+
+    @Test
+    void getUserByEmail_returnsUser_whenUserExists() {
+        // Arrange
+        User user = User.builder()
+                .username("testuser")
+                .password("password")
+                .enabled(true)
+                .email("testuser@example.com")
+                .firstName("Test")
+                .lastName("User")
+                .dateOfBirth(Date.valueOf("1990-01-01"))
+                .authority(Authority.USER)
+                .build();
+        when(userRepository.findByEmail(user.getEmail())).thenReturn(Optional.of(user));
+
+        // Act
+        Optional<User> result = userService.getUserFromEmail(user.getEmail());
+
+        // Assert
+        assertTrue(result.isPresent());
+        assertEquals(user, result.get());
+        verify(userRepository, times(1)).findByEmail(user.getEmail());
+
+    }
+
+    @Test
+    void getPassword_returnsPassword_whenUserExists() {
+        // Arrange
+        User user = User.builder()
+                .username("testuser")
+                .password("password")
+                .enabled(true)
+                .email("testuser@example.com")
+                .firstName("Test")
+                .lastName("User")
+                .dateOfBirth(Date.valueOf("1990-01-01"))
+                .authority(Authority.USER)
+                .build();
+
+        when(userRepository.findByUsername(user.getUsername())).thenReturn(Optional.of(user));
+
+        // Act
+
+        String result = userService.getPassword(user.getUsername());
+
+        // Assert
+
+        assertEquals(user.getPassword(), result);
+        verify(userRepository, times(1)).findByUsername(user.getUsername());
+
+    }
+
+}
\ No newline at end of file