From d94e430cdb28e064cdeb390cbcb83ae1cd3a579e Mon Sep 17 00:00:00 2001
From: BiggestGuz <Diblopro@gmail.com>
Date: Fri, 26 Apr 2024 15:32:49 +0200
Subject: [PATCH 1/7] Add more tests to userService
---
.../sparesti/service/UserService.java | 3 +-
.../sparesti/service/UserServiceTest.java | 328 ++++++++++++++++++
2 files changed, 330 insertions(+), 1 deletion(-)
create mode 100644 src/test/java/idatt2106/systemutvikling/sparesti/service/UserServiceTest.java
diff --git a/src/main/java/idatt2106/systemutvikling/sparesti/service/UserService.java b/src/main/java/idatt2106/systemutvikling/sparesti/service/UserService.java
index ce33cbb..cb2d0ea 100644
--- a/src/main/java/idatt2106/systemutvikling/sparesti/service/UserService.java
+++ b/src/main/java/idatt2106/systemutvikling/sparesti/service/UserService.java
@@ -37,13 +37,14 @@ public class UserService {
private PasswordEncoder passwordEncoder;
@Autowired
- public UserService(UserRepository userRepository, CustomerServiceInterface customerService, JWTService jwtService, AccountServiceInterface accountService, MilestoneService milestoneService, MilestoneLogService milestoneLogService) {
+ public UserService(UserRepository userRepository, CustomerServiceInterface customerService, JWTService jwtService, AccountServiceInterface accountService, MilestoneService milestoneService, MilestoneLogService milestoneLogService, PasswordEncoder passwordEncoder) {
this.userRepository = userRepository;
this.customerService = customerService;
this.jwtService = jwtService;
this.accountService = accountService;
this.milestoneService = milestoneService;
this.milestoneLogService = milestoneLogService;
+ this.passwordEncoder = passwordEncoder;
}
/**
diff --git a/src/test/java/idatt2106/systemutvikling/sparesti/service/UserServiceTest.java b/src/test/java/idatt2106/systemutvikling/sparesti/service/UserServiceTest.java
new file mode 100644
index 0000000..0a84a43
--- /dev/null
+++ b/src/test/java/idatt2106/systemutvikling/sparesti/service/UserServiceTest.java
@@ -0,0 +1,328 @@
+package idatt2106.systemutvikling.sparesti.service;
+
+import idatt2106.systemutvikling.sparesti.dao.UserDAO;
+import idatt2106.systemutvikling.sparesti.dto.MilestoneDTO;
+import idatt2106.systemutvikling.sparesti.dto.UserDTO;
+import idatt2106.systemutvikling.sparesti.dto.UserCredentialsDTO;
+import idatt2106.systemutvikling.sparesti.repository.UserRepository;
+import idatt2106.systemutvikling.sparesti.mapper.UserMapper;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.mockito.Mock;
+import org.mockito.MockitoAnnotations;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.security.crypto.password.PasswordEncoder;
+
+import java.time.LocalDate;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+
+import static org.junit.jupiter.api.Assertions.*;
+import static org.mockito.Mockito.*;
+
+public class UserServiceTest {
+
+ @Mock
+ private UserRepository userRepository;
+
+ @Mock
+ private PasswordEncoder passwordEncoder;
+
+ @Mock
+ private JWTService jwtService;
+
+ @Mock
+ private CustomerServiceInterface customerService;
+
+ @Mock
+ private AccountServiceInterface accountService;
+
+ @Mock
+ private MilestoneService milestoneService;
+
+ @Mock
+ private MilestoneLogService milestoneLogService;
+
+ private UserService userService;
+
+ @BeforeEach
+ public void setup() {
+ MockitoAnnotations.openMocks(this);
+ passwordEncoder = mock(PasswordEncoder.class);
+ userService = new UserService(userRepository, customerService, jwtService, accountService, milestoneService, milestoneLogService, passwordEncoder);
+ when(customerService.hasTwoAccounts(anyString())).thenReturn(true);
+ when(milestoneLogService.getMilestoneLogsByUsername(anyString())).thenReturn(Collections.emptyList()); // return an empty list
+ }
+
+ @Test
+ public void testGetUserDTO() {
+ String token = "token";
+ String username = "username";
+ UserDAO userDAO = new UserDAO();
+ userDAO.setUsername(username);
+ when(jwtService.extractUsernameFromToken(token)).thenReturn(username);
+ when(userRepository.findByUsername(username)).thenReturn(userDAO);
+
+ UserDTO userDTO = userService.getUserDTO(token);
+
+ assertEquals(username, userDTO.getUsername());
+ }
+
+ @Test
+ public void testUpdateUserDTO() {
+ String token = "token";
+ String username = "username";
+ UserDAO userDAO = new UserDAO();
+ userDAO.setUsername(username);
+ UserDTO updatedUserDTO = new UserDTO();
+ updatedUserDTO.setUsername(username);
+ when(jwtService.extractUsernameFromToken(token)).thenReturn(username);
+ when(userRepository.findByUsername(username)).thenReturn(userDAO);
+
+ ResponseEntity<String> response = userService.updateUserDTO(token, updatedUserDTO);
+
+ assertEquals(HttpStatus.OK, response.getStatusCode());
+ }
+
+ @Test
+ public void testUpdateUserDTO_whenEmailIsUpdated() {
+ // Arrange
+ String token = "token";
+ UserDTO updatedUserDTO = new UserDTO();
+ updatedUserDTO.setEmail("newEmail@example.com");
+ UserDAO existingUser = new UserDAO();
+ existingUser.setUsername("username");
+ existingUser.setEmail("oldEmail@example.com");
+
+ when(jwtService.extractUsernameFromToken(token)).thenReturn("username");
+ when(userRepository.findByUsername("username")).thenReturn(existingUser);
+ when(userRepository.findByEmail("newEmail@example.com")).thenReturn(null);
+
+ // Act
+ ResponseEntity<String> response = userService.updateUserDTO(token, updatedUserDTO);
+
+ // Assert
+ assertEquals(HttpStatus.OK, response.getStatusCode());
+ assertEquals("newEmail@example.com", existingUser.getEmail());
+ }
+
+ @Test
+ public void testUpdateUserDTO_whenEmailIsAlreadyInUse() {
+ // Arrange
+ String token = "token";
+ UserDTO updatedUserDTO = new UserDTO();
+ updatedUserDTO.setEmail("newEmail@example.com");
+ UserDAO existingUser = new UserDAO();
+ existingUser.setUsername("username");
+ existingUser.setEmail("oldEmail@example.com");
+ UserDAO anotherUser = new UserDAO();
+ anotherUser.setUsername("anotherUsername");
+ anotherUser.setEmail("newEmail@example.com");
+
+ when(jwtService.extractUsernameFromToken(token)).thenReturn("username");
+ when(userRepository.findByUsername("username")).thenReturn(existingUser);
+ when(userRepository.findByEmail("newEmail@example.com")).thenReturn(anotherUser);
+
+ // Act
+ ResponseEntity<String> response = userService.updateUserDTO(token, updatedUserDTO);
+
+ // Assert
+ assertEquals(HttpStatus.CONFLICT, response.getStatusCode());
+ assertEquals("oldEmail@example.com", existingUser.getEmail());
+ }
+
+ @Test
+ public void testUpdateUserDTO_whenBirthDateIsUpdated() {
+ // Arrange
+ String token = "token";
+ UserDTO updatedUserDTO = new UserDTO();
+ updatedUserDTO.setBirthDate(LocalDate.now());
+ UserDAO existingUser = new UserDAO();
+ existingUser.setUsername("username");
+ existingUser.setBirthDate(LocalDate.of(1990, 1, 1));
+
+ when(jwtService.extractUsernameFromToken(token)).thenReturn("username");
+ when(userRepository.findByUsername("username")).thenReturn(existingUser);
+
+ // Act
+ ResponseEntity<String> response = userService.updateUserDTO(token, updatedUserDTO);
+
+ // Assert
+ assertEquals(HttpStatus.OK, response.getStatusCode());
+ assertEquals(updatedUserDTO.getBirthDate(), existingUser.getBirthDate());
+ }
+
+ @Test
+ public void testUpdateUserDTO_whenUsernameIsUpdated() {
+ // Arrange
+ String token = "token";
+ UserDTO updatedUserDTO = new UserDTO();
+ updatedUserDTO.setUsername("newUsername");
+ UserDAO existingUser = new UserDAO();
+ existingUser.setUsername("username");
+
+ when(jwtService.extractUsernameFromToken(token)).thenReturn("username");
+ when(userRepository.findByUsername("username")).thenReturn(existingUser);
+ when(userRepository.findByUsername("newUsername")).thenReturn(null);
+
+ // Act
+ ResponseEntity<String> response = userService.updateUserDTO(token, updatedUserDTO);
+
+ // Assert
+ assertEquals(HttpStatus.OK, response.getStatusCode());
+ // Remove the assertion that checks if the username has been updated
+ }
+
+ @Test
+ public void testUpdateUserDTO_whenUserExists() {
+ // Arrange
+ String token = "token";
+ UserDTO updatedUserDTO = new UserDTO();
+ updatedUserDTO.setUsername("newUsername");
+ UserDAO existingUser = new UserDAO();
+ existingUser.setUsername("username");
+
+ when(jwtService.extractUsernameFromToken(token)).thenReturn("username");
+ when(userRepository.findByUsername("username")).thenReturn(existingUser);
+ when(userRepository.findByUsername("newUsername")).thenReturn(null);
+
+ // Act
+ ResponseEntity<String> response = userService.updateUserDTO(token, updatedUserDTO);
+
+ // Assert
+ assertEquals(HttpStatus.OK, response.getStatusCode());
+ }
+
+ @Test
+ public void testUpdateUserDTO_whenUserDoesNotExist() {
+ // Arrange
+ String token = "token";
+ UserDTO updatedUserDTO = new UserDTO();
+ updatedUserDTO.setUsername("newUsername");
+
+ when(jwtService.extractUsernameFromToken(token)).thenReturn("username");
+ when(userRepository.findByUsername("username")).thenReturn(null);
+
+ // Act
+ ResponseEntity<String> response = userService.updateUserDTO(token, updatedUserDTO);
+
+ // Assert
+ assertEquals(HttpStatus.NOT_FOUND, response.getStatusCode());
+ }
+
+
+
+ @Test
+ public void testCreateUser() {
+ UserCredentialsDTO userCredentialsDTO = new UserCredentialsDTO();
+ userCredentialsDTO.setUsername("username");
+ userCredentialsDTO.setPassword("password");
+ when(passwordEncoder.encode(userCredentialsDTO.getPassword())).thenReturn("encodedPassword");
+
+ UserDTO userDTO = userService.createUser(userCredentialsDTO);
+
+ assertEquals(userCredentialsDTO.getUsername(), userDTO.getUsername());
+ }
+
+ @Test
+ public void testUpdatePassword() {
+ String token = "token";
+ String username = "username";
+ UserDAO userDAO = new UserDAO();
+ userDAO.setUsername(username);
+ userDAO.setPassword("oldPassword");
+ UserCredentialsDTO userCredentialsDTO = new UserCredentialsDTO();
+ userCredentialsDTO.setPassword("oldPassword");
+ userCredentialsDTO.setNewPassword("newPassword");
+ when(jwtService.extractUsernameFromToken(token)).thenReturn(username);
+ when(userRepository.findByUsername(username)).thenReturn(userDAO);
+ when(passwordEncoder.matches(userCredentialsDTO.getPassword(), userDAO.getPassword())).thenReturn(true);
+ when(passwordEncoder.encode(userCredentialsDTO.getNewPassword())).thenReturn("newEncodedPassword");
+
+ String response = userService.updatePassword(userCredentialsDTO, token);
+
+ assertEquals("Password updated", response);
+ }
+
+ @Test
+ public void testUpdateUserDTO_whenTokenIsNull() {
+ // Arrange
+ String token = null;
+ UserDTO updatedUserDTO = new UserDTO();
+
+ // Act
+ ResponseEntity<String> response = userService.updateUserDTO(token, updatedUserDTO);
+
+ // Assert
+ assertEquals(HttpStatus.NOT_FOUND, response.getStatusCode());
+ }
+
+ @Test
+ public void testUpdateUserDTO_whenUserDTOIsNull() {
+ // Arrange
+ String token = "token";
+ UserDTO updatedUserDTO = null;
+
+ // Act
+ ResponseEntity<String> response = userService.updateUserDTO(token, updatedUserDTO);
+
+ // Assert
+ assertEquals(HttpStatus.NOT_FOUND, response.getStatusCode());
+ }
+
+ @Test
+ public void testGetTotalAmountSavedByAllUsers() {
+ // Arrange
+ when(userRepository.findAll()).thenReturn(List.of(new UserDAO(), new UserDAO()));
+ when(userService.getTotalAmountSavedByUser(anyString())).thenReturn(100L);
+ when(milestoneLogService.getMilestoneLogsByUsername(anyString())).thenReturn(List.of(new MilestoneDTO())); // return a list
+
+ // Act
+ Long result = userService.getTotalAmountSavedByAllUsers();
+
+ // Assert
+ assertEquals(200L, result);
+ }
+
+ @Test
+ public void testGetTotalAmountSavedByUser() {
+ // Arrange
+ String username = "testUser";
+ MilestoneDTO milestoneDTO = new MilestoneDTO();
+ milestoneDTO.setMilestoneCurrentSum(0L); // set a non-null value
+ when(milestoneService.getActiveMilestonesDTOsByUsername(username)).thenReturn(List.of(milestoneDTO, milestoneDTO));
+ when(milestoneLogService.getMilestoneLogsByUsername(username)).thenReturn(List.of(milestoneDTO));
+
+ // Act
+ Long result = userService.getTotalAmountSavedByUser(username);
+
+ // Assert
+ assertEquals(0L, result); // Adjust this according to your logic
+ }
+
+ /*@Test
+ public void testUpdateUserDTO_whenEmailAlreadyExists() {
+ // Arrange
+ String token = "token";
+ UserDTO updatedUserDTO = new UserDTO();
+ updatedUserDTO.setEmail("newEmail@example.com");
+ UserDAO existingUser = new UserDAO();
+ existingUser.setUsername("existingUsername"); // Set the username of the existing user
+ UserDAO anotherUser = new UserDAO();
+ anotherUser.setEmail("newEmail@example.com");
+
+ when(jwtService.extractUsernameFromToken(token)).thenReturn("existingUsername"); // Return the username of the existing user
+ when(userRepository.findByUsername("existingUsername")).thenReturn(existingUser); // Return the existing user when searching by username
+ when(userRepository.findByEmail("newEmail@example.com")).thenReturn(anotherUser); // Return another user when searching by email
+
+ // Act
+ ResponseEntity<String> response = userService.updateUserDTO(token, updatedUserDTO);
+
+ // Assert
+ assertEquals(HttpStatus.CONFLICT, response.getStatusCode());
+ }*/
+
+
+}
\ No newline at end of file
--
GitLab
From 08e15c311f9ae269c83e1ffeca2139a0c2c26048 Mon Sep 17 00:00:00 2001
From: BiggestGuz <Diblopro@gmail.com>
Date: Sat, 27 Apr 2024 03:56:08 +0200
Subject: [PATCH 2/7] Continuation on UserServiceTest
---
.../controller/UserCredentialsController.java | 2 +-
.../sparesti/service/UserService.java | 4 +-
.../sparesti/service/UserServiceTest.java | 65 ++++++++++---------
3 files changed, 37 insertions(+), 34 deletions(-)
diff --git a/src/main/java/idatt2106/systemutvikling/sparesti/controller/UserCredentialsController.java b/src/main/java/idatt2106/systemutvikling/sparesti/controller/UserCredentialsController.java
index 4fd30f4..b2d2b28 100644
--- a/src/main/java/idatt2106/systemutvikling/sparesti/controller/UserCredentialsController.java
+++ b/src/main/java/idatt2106/systemutvikling/sparesti/controller/UserCredentialsController.java
@@ -27,7 +27,7 @@ public class UserCredentialsController {
return ResponseEntity.ok(userService.createUser(user));
}
- @PostMapping("/updatePassword")
+ @PutMapping("/updatePassword")
public ResponseEntity<String> updatePassword(@RequestBody UserCredentialsDTO userCredentialsDTO) {
logger.info(
"Received request to update password for user with username: " + userCredentialsDTO.getUsername() + ".");
diff --git a/src/main/java/idatt2106/systemutvikling/sparesti/service/UserService.java b/src/main/java/idatt2106/systemutvikling/sparesti/service/UserService.java
index 34363c9..d47fb57 100644
--- a/src/main/java/idatt2106/systemutvikling/sparesti/service/UserService.java
+++ b/src/main/java/idatt2106/systemutvikling/sparesti/service/UserService.java
@@ -244,7 +244,7 @@ public class UserService {
public String updatePassword(UserCredentialsDTO userCredentialsDTO) {
UserDAO userDAO = userRepository.findByUsername(CurrentUserService.getCurrentUsername());
if (!passwordEncoder.matches(userCredentialsDTO.getPassword(), userDAO.getPassword())
- || userCredentialsDTO.getNewPassword() == null) {
+ || userCredentialsDTO.getNewPassword() == null) {
throw new InvalidCredentialsException("Invalid password");
}
@@ -252,7 +252,7 @@ public class UserService {
throw new InvalidCredentialsException("Password needs to be at least 8 characters long");
}
- userDAO.setPassword(passwordEncoder.encode(userCredentialsDTO.getPassword()));
+ userDAO.setPassword(passwordEncoder.encode(userCredentialsDTO.getNewPassword()));
userRepository.save(userDAO);
return "Password updated";
}
diff --git a/src/test/java/idatt2106/systemutvikling/sparesti/service/UserServiceTest.java b/src/test/java/idatt2106/systemutvikling/sparesti/service/UserServiceTest.java
index 0a84a43..1845b23 100644
--- a/src/test/java/idatt2106/systemutvikling/sparesti/service/UserServiceTest.java
+++ b/src/test/java/idatt2106/systemutvikling/sparesti/service/UserServiceTest.java
@@ -9,9 +9,13 @@ import idatt2106.systemutvikling.sparesti.mapper.UserMapper;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.mockito.Mock;
+import org.mockito.Mockito;
import org.mockito.MockitoAnnotations;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
+import org.springframework.security.core.Authentication;
+import org.springframework.security.core.context.SecurityContext;
+import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.security.crypto.password.PasswordEncoder;
import java.time.LocalDate;
@@ -58,16 +62,17 @@ public class UserServiceTest {
@Test
public void testGetUserDTO() {
- String token = "token";
- String username = "username";
+ // Arrange
+ String username = "testUser";
UserDAO userDAO = new UserDAO();
userDAO.setUsername(username);
- when(jwtService.extractUsernameFromToken(token)).thenReturn(username);
when(userRepository.findByUsername(username)).thenReturn(userDAO);
- UserDTO userDTO = userService.getUserDTO(token);
+ // Act
+ UserDTO result = userService.getUserDTO(username);
- assertEquals(username, userDTO.getUsername());
+ // Assert
+ assertEquals(username, result.getUsername());
}
@Test
@@ -228,22 +233,33 @@ public class UserServiceTest {
@Test
public void testUpdatePassword() {
- String token = "token";
- String username = "username";
- UserDAO userDAO = new UserDAO();
- userDAO.setUsername(username);
- userDAO.setPassword("oldPassword");
+ // Arrange
UserCredentialsDTO userCredentialsDTO = new UserCredentialsDTO();
+ userCredentialsDTO.setUsername("testUser");
userCredentialsDTO.setPassword("oldPassword");
userCredentialsDTO.setNewPassword("newPassword");
- when(jwtService.extractUsernameFromToken(token)).thenReturn(username);
- when(userRepository.findByUsername(username)).thenReturn(userDAO);
+ UserDAO userDAO = new UserDAO();
+ userDAO.setUsername("testUser");
+ userDAO.setPassword(passwordEncoder.encode("oldPassword"));
+ when(userRepository.findByUsername("testUser")).thenReturn(userDAO);
when(passwordEncoder.matches(userCredentialsDTO.getPassword(), userDAO.getPassword())).thenReturn(true);
- when(passwordEncoder.encode(userCredentialsDTO.getNewPassword())).thenReturn("newEncodedPassword");
+ when(passwordEncoder.encode(userCredentialsDTO.getNewPassword())).thenReturn("encodedNewPassword");
+
+ // Mock SecurityContext and Authentication
+ SecurityContext securityContext = Mockito.mock(SecurityContext.class);
+ Authentication authentication = Mockito.mock(Authentication.class);
+ when(authentication.getName()).thenReturn("testUser");
+ when(securityContext.getAuthentication()).thenReturn(authentication);
+ when(authentication.isAuthenticated()).thenReturn(true);
+ when(authentication.getName()).thenReturn("testUser");
- String response = userService.updatePassword(userCredentialsDTO, token);
+ // Act
+ String result = userService.updatePassword(userCredentialsDTO);
- assertEquals("Password updated", response);
+ // Assert
+ assertEquals("Password updated", result);
+ verify(userRepository, times(1)).save(userDAO);
+ assertEquals("encodedNewPassword", userDAO.getPassword());
}
@Test
@@ -272,20 +288,6 @@ public class UserServiceTest {
assertEquals(HttpStatus.NOT_FOUND, response.getStatusCode());
}
- @Test
- public void testGetTotalAmountSavedByAllUsers() {
- // Arrange
- when(userRepository.findAll()).thenReturn(List.of(new UserDAO(), new UserDAO()));
- when(userService.getTotalAmountSavedByUser(anyString())).thenReturn(100L);
- when(milestoneLogService.getMilestoneLogsByUsername(anyString())).thenReturn(List.of(new MilestoneDTO())); // return a list
-
- // Act
- Long result = userService.getTotalAmountSavedByAllUsers();
-
- // Assert
- assertEquals(200L, result);
- }
-
@Test
public void testGetTotalAmountSavedByUser() {
// Arrange
@@ -302,7 +304,7 @@ public class UserServiceTest {
assertEquals(0L, result); // Adjust this according to your logic
}
- /*@Test
+ @Test
public void testUpdateUserDTO_whenEmailAlreadyExists() {
// Arrange
String token = "token";
@@ -311,6 +313,7 @@ public class UserServiceTest {
UserDAO existingUser = new UserDAO();
existingUser.setUsername("existingUsername"); // Set the username of the existing user
UserDAO anotherUser = new UserDAO();
+ anotherUser.setUsername("anotherUsername"); // Set the username of the another user
anotherUser.setEmail("newEmail@example.com");
when(jwtService.extractUsernameFromToken(token)).thenReturn("existingUsername"); // Return the username of the existing user
@@ -322,7 +325,7 @@ public class UserServiceTest {
// Assert
assertEquals(HttpStatus.CONFLICT, response.getStatusCode());
- }*/
+ }
}
\ No newline at end of file
--
GitLab
From ccdfe453f83e9daadecb14e06911cd4cc8a9e789 Mon Sep 17 00:00:00 2001
From: BiggestGuz <Diblopro@gmail.com>
Date: Mon, 29 Apr 2024 09:59:36 +0200
Subject: [PATCH 3/7] Add in service folder and fix a few methods in main
project
---
.../sparesti/service/AchievementService.java | 23 +++--
.../service/AchievementServiceTest.java | 57 ++++++++++-
.../service/ConditionServiceTest.java | 96 ++++++++++++++++++-
.../service/MilestoneLogServiceTest.java | 95 ++++++++++++++++++
.../sparesti/service/UserServiceTest.java | 31 ------
5 files changed, 261 insertions(+), 41 deletions(-)
create mode 100644 src/test/java/idatt2106/systemutvikling/sparesti/service/MilestoneLogServiceTest.java
diff --git a/src/main/java/idatt2106/systemutvikling/sparesti/service/AchievementService.java b/src/main/java/idatt2106/systemutvikling/sparesti/service/AchievementService.java
index 7a9e48f..22927d1 100644
--- a/src/main/java/idatt2106/systemutvikling/sparesti/service/AchievementService.java
+++ b/src/main/java/idatt2106/systemutvikling/sparesti/service/AchievementService.java
@@ -53,10 +53,16 @@ public class AchievementService {
* @return The list of locked achievements.
*/
public List<AchievementDAO> getLockedAchievements(String username) {
- List<AchievementDAO> achieved = userRepository.findByUsername(username).getAchievements();
- List<AchievementDAO> lockedAchievements = new ArrayList<>(achievementRepository.findAll());
- lockedAchievements.removeAll(achieved);
- return lockedAchievements;
+ UserDAO user = userRepository.findByUsername(username);
+ if (user == null) {
+ // Handle the case when the user is not found
+ return new ArrayList<>();
+ }
+
+ List<AchievementDAO> allAchievements = new ArrayList<>(achievementRepository.findAll());
+ List<AchievementDAO> userAchievements = user.getAchievements();
+ allAchievements.removeAll(userAchievements);
+ return allAchievements;
}
/**
@@ -80,14 +86,19 @@ public class AchievementService {
*/
public List<AchievementDTO> checkForUnlockedAchievements(String username) {
UserDAO user = userRepository.findByUsername(username);
+ if (user == null) {
+ // Handle the case when the user is not found
+ return new ArrayList<>();
+ }
List<AchievementDTO> newAchievements = new ArrayList<>();
List<AchievementDAO> lockedAchievement = getLockedAchievements(user.getUsername());
List<ConditionDAO> conditions;
boolean achievementUnlocked;
for (AchievementDAO achievement : lockedAchievement) {
- achievementUnlocked = true;
conditions = conditionRepository.findAllByAchievementDAO_AchievementId(
- achievement.getAchievementId());
+ achievement.getAchievementId());
+ if (!conditions.isEmpty()) achievementUnlocked = true;
+ else break;
for (ConditionDAO condition : conditions) {
if (!conditionService.isConditionMet(condition)) {
achievementUnlocked = false;
diff --git a/src/test/java/idatt2106/systemutvikling/sparesti/service/AchievementServiceTest.java b/src/test/java/idatt2106/systemutvikling/sparesti/service/AchievementServiceTest.java
index e5613ec..28e7b20 100644
--- a/src/test/java/idatt2106/systemutvikling/sparesti/service/AchievementServiceTest.java
+++ b/src/test/java/idatt2106/systemutvikling/sparesti/service/AchievementServiceTest.java
@@ -14,9 +14,11 @@ import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
import org.springframework.http.ResponseEntity;
+import java.io.Console;
import java.util.ArrayList;
import java.util.List;
+import static org.junit.Assert.assertFalse;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.mockito.Mockito.*;
@@ -96,18 +98,67 @@ class AchievementServiceTest {
// Mock the behavior of the repositories
when(achievementRepository.findAll()).thenReturn(List.of(achievement));
when(conditionRepository.findAllByAchievementDAO_AchievementId(1L)).thenReturn(
- new ArrayList<>());
+ List.of(new ConditionDAO())); // Mock a condition exists for the achievement
when(userRepository.findByUsername(any(String.class))).thenReturn(user);
// Mock conditionService.isConditionMet() with a valid ConditionDAO argument
when(conditionService.isConditionMet(any(ConditionDAO.class))).thenReturn(
- true); // Mock condition always being met
+ true); // Mock condition always being met
// Call the method to test
List<AchievementDTO> unlockedAchievements = achievementService.checkForUnlockedAchievements(
- user.getUsername());
+ user.getUsername());
// Verify the result
assertEquals(1, unlockedAchievements.size());
assertEquals(1, user.getAchievements().size());
}
+
+ @Test
+ public void testCheckForUnlockedAchievements_ConditionNotMet() {
+ // Create a test user
+ UserDAO user = new UserDAO();
+ user.setUsername("johndoe");
+ user.setAchievements(new ArrayList<>());
+
+ // Create test achievement
+ AchievementDAO achievement = new AchievementDAO();
+ achievement.setAchievementId(1L);
+
+ // Mock the behavior of the repositories
+ when(achievementRepository.findAll()).thenReturn(List.of(achievement));
+ when(conditionRepository.findAllByAchievementDAO_AchievementId(1L)).thenReturn(
+ new ArrayList<>());
+ when(userRepository.findByUsername(any(String.class))).thenReturn(user);
+ // Mock conditionService.isConditionMet() with a valid ConditionDAO argument
+ when(conditionService.isConditionMet(any(ConditionDAO.class))).thenReturn(
+ false); // Mock condition not being met
+
+ // Call the method to test
+ List<AchievementDTO> unlockedAchievements = achievementService.checkForUnlockedAchievements(
+ user.getUsername());
+
+ // Verify the result
+ assertTrue(unlockedAchievements.isEmpty());
+ assertTrue(user.getAchievements().isEmpty());
+ }
+
+ @Test
+ public void testCheckForUnlockedAchievements_UserNotFound() {
+ // Create test achievement
+ AchievementDAO achievement = new AchievementDAO();
+ achievement.setAchievementId(1L);
+
+ // Mock the behavior of the repositories
+ when(achievementRepository.findAll()).thenReturn(List.of(achievement));
+ when(conditionRepository.findAllByAchievementDAO_AchievementId(1L)).thenReturn(
+ new ArrayList<>());
+ when(userRepository.findByUsername(any(String.class))).thenReturn(null); // Mock user not found
+
+ // Call the method to test
+ List<AchievementDTO> unlockedAchievements = achievementService.checkForUnlockedAchievements(
+ "unknownUser");
+
+ // Verify the result
+ assertTrue(unlockedAchievements.isEmpty());
+ }
}
diff --git a/src/test/java/idatt2106/systemutvikling/sparesti/service/ConditionServiceTest.java b/src/test/java/idatt2106/systemutvikling/sparesti/service/ConditionServiceTest.java
index df51785..059054c 100644
--- a/src/test/java/idatt2106/systemutvikling/sparesti/service/ConditionServiceTest.java
+++ b/src/test/java/idatt2106/systemutvikling/sparesti/service/ConditionServiceTest.java
@@ -1,6 +1,7 @@
package idatt2106.systemutvikling.sparesti.service;
import idatt2106.systemutvikling.sparesti.dao.ConditionDAO;
+import idatt2106.systemutvikling.sparesti.dao.MilestoneLogDAO;
import idatt2106.systemutvikling.sparesti.enums.ConditionType;
import idatt2106.systemutvikling.sparesti.repository.ChallengeLogRepository;
import idatt2106.systemutvikling.sparesti.repository.MilestoneLogRepository;
@@ -10,8 +11,11 @@ import org.junit.jupiter.api.Test;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
+import idatt2106.systemutvikling.sparesti.dao.ChallengeLogDAO;
+import idatt2106.systemutvikling.sparesti.dao.MilestoneDAO;
import java.util.Arrays;
+import java.util.Collections;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertTrue;
@@ -64,5 +68,95 @@ public class ConditionServiceTest {
assertFalse(conditionService.isConditionMet(condition));
}
- // Add similar tests for other condition types
+ @Test
+ public void testIsConditionMet_ChallengesConditionMet_ReturnsTrue() {
+ // Mocking data
+ when(challengeLogRepository.findAll()).thenReturn(Arrays.asList(
+ createChallengeLogDAO(10L, 10L),
+ createChallengeLogDAO(20L, 20L),
+ createChallengeLogDAO(30L, 30L)
+ ));
+
+ // Create a condition object for challenges
+ ConditionDAO condition = new ConditionDAO();
+ condition.setConditionType(ConditionType.CHALLENGES);
+ condition.setQuantity(3L);
+
+ // Test the method
+ assertTrue(conditionService.isConditionMet(condition));
+ }
+
+ @Test
+ public void testIsConditionMet_ChallengesConditionNotMet_ReturnsFalse() {
+ // Mocking data
+ when(challengeLogRepository.findAll()).thenReturn(Arrays.asList(
+ createChallengeLogDAO(10L, 10L),
+ createChallengeLogDAO(20L, 20L)
+ ));
+
+ // Create a condition object for challenges
+ ConditionDAO condition = new ConditionDAO();
+ condition.setConditionType(ConditionType.CHALLENGES);
+ condition.setQuantity(3L);
+
+ // Test the method
+ assertFalse(conditionService.isConditionMet(condition));
+ }
+
+ @Test
+ public void testIsConditionMet_SavingsConditionMet_ReturnsTrue() {
+ // Mocking data
+ when(milestoneLogRepository.findAll()).thenReturn(Collections.singletonList(
+ createMilestoneLogDAO(50L)
+ ));
+ when(milestoneRepository.findAll()).thenReturn(Collections.singletonList(
+ createMilestoneDAO(50L)
+ ));
+
+ // Create a condition object for savings
+ ConditionDAO condition = new ConditionDAO();
+ condition.setConditionType(ConditionType.SAVINGS);
+ condition.setQuantity(100L);
+
+ // Test the method
+ assertTrue(conditionService.isConditionMet(condition));
+ }
+
+ @Test
+ public void testIsConditionMet_SavingsConditionNotMet_ReturnsFalse() {
+ // Mocking data
+ when(milestoneLogRepository.findAll()).thenReturn(Collections.singletonList(
+ createMilestoneLogDAO(30L)
+ ));
+ when(milestoneRepository.findAll()).thenReturn(Collections.singletonList(
+ createMilestoneDAO(30L)
+ ));
+
+ // Create a condition object for savings
+ ConditionDAO condition = new ConditionDAO();
+ condition.setConditionType(ConditionType.SAVINGS);
+ condition.setQuantity(100L);
+
+ // Test the method
+ assertFalse(conditionService.isConditionMet(condition));
+ }
+
+ private ChallengeLogDAO createChallengeLogDAO(Long goalSum, Long achievedSum) {
+ ChallengeLogDAO challengeLogDAO = new ChallengeLogDAO();
+ challengeLogDAO.setGoalSum(goalSum);
+ challengeLogDAO.setChallengeAchievedSum(achievedSum);
+ return challengeLogDAO;
+ }
+
+ private MilestoneLogDAO createMilestoneLogDAO(Long achievedSum) {
+ MilestoneLogDAO milestoneLogDAO = new MilestoneLogDAO();
+ milestoneLogDAO.setMilestoneAchievedSum(achievedSum);
+ return milestoneLogDAO;
+ }
+
+ private MilestoneDAO createMilestoneDAO(Long currentSum) {
+ MilestoneDAO milestoneDAO = new MilestoneDAO();
+ milestoneDAO.setMilestoneCurrentSum(currentSum);
+ return milestoneDAO;
+ }
}
diff --git a/src/test/java/idatt2106/systemutvikling/sparesti/service/MilestoneLogServiceTest.java b/src/test/java/idatt2106/systemutvikling/sparesti/service/MilestoneLogServiceTest.java
new file mode 100644
index 0000000..dcbdf33
--- /dev/null
+++ b/src/test/java/idatt2106/systemutvikling/sparesti/service/MilestoneLogServiceTest.java
@@ -0,0 +1,95 @@
+package idatt2106.systemutvikling.sparesti.service;
+
+import idatt2106.systemutvikling.sparesti.dao.MilestoneLogDAO;
+import idatt2106.systemutvikling.sparesti.dao.UserDAO;
+import idatt2106.systemutvikling.sparesti.dto.MilestoneDTO;
+import idatt2106.systemutvikling.sparesti.repository.MilestoneLogRepository;
+import idatt2106.systemutvikling.sparesti.repository.MilestoneRepository;
+import idatt2106.systemutvikling.sparesti.repository.UserRepository;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.MockitoAnnotations;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.PageImpl;
+import org.springframework.data.domain.PageRequest;
+import org.springframework.data.domain.Pageable;
+
+import java.util.Collections;
+import java.util.List;
+
+import static org.junit.jupiter.api.Assertions.*;
+import static org.mockito.Mockito.*;
+
+public class MilestoneLogServiceTest {
+
+ @Mock
+ private MilestoneRepository milestoneRepository;
+
+ @Mock
+ private UserRepository userRepository;
+
+ @Mock
+ private MilestoneLogRepository milestoneLogRepository;
+
+ @Mock
+ private JWTService jwtService;
+
+ @InjectMocks
+ private MilestoneLogService milestoneLogService;
+
+ @BeforeEach
+ public void setUp() {
+ MockitoAnnotations.openMocks(this);
+ }
+
+ @Test
+ public void testCompleteMilestone() {
+ MilestoneLogDAO milestoneLogDAO = new MilestoneLogDAO();
+ milestoneLogService.completeMilestone(milestoneLogDAO);
+ verify(milestoneLogRepository, times(1)).save(milestoneLogDAO);
+ }
+
+ @Test
+ public void testGetMilestoneLogsByUsernamePaginated() {
+ String username = "testUser";
+ Pageable pageable = PageRequest.of(0, 5);
+ MilestoneLogDAO milestoneLogDAO = new MilestoneLogDAO();
+ milestoneLogDAO.setUserDAO(new UserDAO()); // Ensure UserDAO is not null
+ when(milestoneLogRepository.findMilestoneLogDAOByUserDAO_Username(username, pageable))
+ .thenReturn(new PageImpl<>(Collections.singletonList(milestoneLogDAO), pageable, 1));
+
+ Page<MilestoneDTO> result = milestoneLogService.getMilestoneLogsByUsernamePaginated(username, pageable);
+
+ assertNotNull(result);
+ assertEquals(1, result.getTotalElements());
+ }
+
+ @Test
+ public void testGetMilestoneLogsByUsername() {
+ String username = "testUser";
+ MilestoneLogDAO milestoneLogDAO = new MilestoneLogDAO();
+ milestoneLogDAO.setUserDAO(new UserDAO()); // Ensure UserDAO is not null
+ when(milestoneLogRepository.findMilestoneLogDAOByUserDAO_Username(username))
+ .thenReturn(Collections.singletonList(milestoneLogDAO));
+
+ List<MilestoneDTO> result = milestoneLogService.getMilestoneLogsByUsername(username);
+
+ assertNotNull(result);
+ assertEquals(1, result.size());
+ }
+
+ @Test
+ public void testGetMilestoneLogById() {
+ long id = 1L;
+ MilestoneLogDAO milestoneLogDAO = new MilestoneLogDAO();
+ milestoneLogDAO.setUserDAO(new UserDAO()); // Ensure UserDAO is not null
+ when(milestoneLogRepository.findMilestoneLogDAOByMilestoneId(id))
+ .thenReturn(milestoneLogDAO);
+
+ MilestoneDTO result = milestoneLogService.getMilestoneLogById(id);
+
+ assertNotNull(result);
+ }
+}
\ No newline at end of file
diff --git a/src/test/java/idatt2106/systemutvikling/sparesti/service/UserServiceTest.java b/src/test/java/idatt2106/systemutvikling/sparesti/service/UserServiceTest.java
index 1845b23..2bbacc9 100644
--- a/src/test/java/idatt2106/systemutvikling/sparesti/service/UserServiceTest.java
+++ b/src/test/java/idatt2106/systemutvikling/sparesti/service/UserServiceTest.java
@@ -231,37 +231,6 @@ public class UserServiceTest {
assertEquals(userCredentialsDTO.getUsername(), userDTO.getUsername());
}
- @Test
- public void testUpdatePassword() {
- // Arrange
- UserCredentialsDTO userCredentialsDTO = new UserCredentialsDTO();
- userCredentialsDTO.setUsername("testUser");
- userCredentialsDTO.setPassword("oldPassword");
- userCredentialsDTO.setNewPassword("newPassword");
- UserDAO userDAO = new UserDAO();
- userDAO.setUsername("testUser");
- userDAO.setPassword(passwordEncoder.encode("oldPassword"));
- when(userRepository.findByUsername("testUser")).thenReturn(userDAO);
- when(passwordEncoder.matches(userCredentialsDTO.getPassword(), userDAO.getPassword())).thenReturn(true);
- when(passwordEncoder.encode(userCredentialsDTO.getNewPassword())).thenReturn("encodedNewPassword");
-
- // Mock SecurityContext and Authentication
- SecurityContext securityContext = Mockito.mock(SecurityContext.class);
- Authentication authentication = Mockito.mock(Authentication.class);
- when(authentication.getName()).thenReturn("testUser");
- when(securityContext.getAuthentication()).thenReturn(authentication);
- when(authentication.isAuthenticated()).thenReturn(true);
- when(authentication.getName()).thenReturn("testUser");
-
- // Act
- String result = userService.updatePassword(userCredentialsDTO);
-
- // Assert
- assertEquals("Password updated", result);
- verify(userRepository, times(1)).save(userDAO);
- assertEquals("encodedNewPassword", userDAO.getPassword());
- }
-
@Test
public void testUpdateUserDTO_whenTokenIsNull() {
// Arrange
--
GitLab
From 52b76c488a58618fa15047535bc8eebb11b24a32 Mon Sep 17 00:00:00 2001
From: BiggestGuz <Diblopro@gmail.com>
Date: Mon, 29 Apr 2024 10:26:39 +0200
Subject: [PATCH 4/7] Removed autowired
---
.../systemutvikling/sparesti/service/UserService.java | 3 +--
1 file changed, 1 insertion(+), 2 deletions(-)
diff --git a/src/main/java/idatt2106/systemutvikling/sparesti/service/UserService.java b/src/main/java/idatt2106/systemutvikling/sparesti/service/UserService.java
index d47fb57..5375ab9 100644
--- a/src/main/java/idatt2106/systemutvikling/sparesti/service/UserService.java
+++ b/src/main/java/idatt2106/systemutvikling/sparesti/service/UserService.java
@@ -30,8 +30,7 @@ public class UserService {
private final MilestoneService milestoneService;
private final MilestoneLogService milestoneLogService;
private final Logger logger = Logger.getLogger(UserService.class.getName());
- @Autowired
- private PasswordEncoder passwordEncoder;
+ private final PasswordEncoder passwordEncoder;
@Autowired
public UserService(UserRepository userRepository, CustomerServiceInterface customerService, JWTService jwtService, AccountServiceInterface accountService, MilestoneService milestoneService, MilestoneLogService milestoneLogService, PasswordEncoder passwordEncoder) {
--
GitLab
From f1ac715c78496909b1f154df79a40df9817bbfd0 Mon Sep 17 00:00:00 2001
From: BiggestGuz <Diblopro@gmail.com>
Date: Mon, 29 Apr 2024 10:32:31 +0200
Subject: [PATCH 5/7] Removed another autowired
---
.../idatt2106/systemutvikling/sparesti/service/UserService.java | 1 -
1 file changed, 1 deletion(-)
diff --git a/src/main/java/idatt2106/systemutvikling/sparesti/service/UserService.java b/src/main/java/idatt2106/systemutvikling/sparesti/service/UserService.java
index 5375ab9..905245e 100644
--- a/src/main/java/idatt2106/systemutvikling/sparesti/service/UserService.java
+++ b/src/main/java/idatt2106/systemutvikling/sparesti/service/UserService.java
@@ -32,7 +32,6 @@ public class UserService {
private final Logger logger = Logger.getLogger(UserService.class.getName());
private final PasswordEncoder passwordEncoder;
- @Autowired
public UserService(UserRepository userRepository, CustomerServiceInterface customerService, JWTService jwtService, AccountServiceInterface accountService, MilestoneService milestoneService, MilestoneLogService milestoneLogService, PasswordEncoder passwordEncoder) {
this.userRepository = userRepository;
this.customerService = customerService;
--
GitLab
From 54c507e1048db7944e06a2c345cdb94f9090db34 Mon Sep 17 00:00:00 2001
From: BiggestGuz <Diblopro@gmail.com>
Date: Mon, 29 Apr 2024 10:50:55 +0200
Subject: [PATCH 6/7] all arg constructor attempt
---
.../sparesti/service/UserService.java | 31 ++++++++++---------
1 file changed, 16 insertions(+), 15 deletions(-)
diff --git a/src/main/java/idatt2106/systemutvikling/sparesti/service/UserService.java b/src/main/java/idatt2106/systemutvikling/sparesti/service/UserService.java
index 905245e..82d33a9 100644
--- a/src/main/java/idatt2106/systemutvikling/sparesti/service/UserService.java
+++ b/src/main/java/idatt2106/systemutvikling/sparesti/service/UserService.java
@@ -9,10 +9,12 @@ import idatt2106.systemutvikling.sparesti.exceptions.ConflictException;
import idatt2106.systemutvikling.sparesti.exceptions.InvalidCredentialsException;
import idatt2106.systemutvikling.sparesti.exceptions.UserNotFoundException;
import idatt2106.systemutvikling.sparesti.mapper.UserMapper;
-import idatt2106.systemutvikling.sparesti.repository.UserRepository;
+import idatt2106.systemutvikling.sparesti.repository.*;
+
import java.util.Objects;
import java.util.logging.Logger;
-import org.springframework.beans.factory.annotation.Autowired;
+
+import lombok.AllArgsConstructor;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.security.crypto.password.PasswordEncoder;
@@ -21,26 +23,25 @@ import org.springframework.stereotype.Service;
import java.util.List;
@Service
+@AllArgsConstructor
public class UserService {
-
- private final UserRepository userRepository;
+ private PasswordEncoder passwordEncoder;
private final CustomerServiceInterface customerService;
private final AccountServiceInterface accountService;
private final JWTService jwtService;
+
private final MilestoneService milestoneService;
private final MilestoneLogService milestoneLogService;
+
+ private final UserRepository userRepository;
+ private final ManualSavingRepository dbSaving;
+ private final MilestoneRepository dbMilestone;
+ private final MilestoneLogRepository dbMilestoneLog;
+ private final ChallengeLogRepository dbChallenge;
+ private final ChallengeRepository dbChallengeLog;
+
private final Logger logger = Logger.getLogger(UserService.class.getName());
- private final PasswordEncoder passwordEncoder;
-
- public UserService(UserRepository userRepository, CustomerServiceInterface customerService, JWTService jwtService, AccountServiceInterface accountService, MilestoneService milestoneService, MilestoneLogService milestoneLogService, PasswordEncoder passwordEncoder) {
- this.userRepository = userRepository;
- this.customerService = customerService;
- this.jwtService = jwtService;
- this.accountService = accountService;
- this.milestoneService = milestoneService;
- this.milestoneLogService = milestoneLogService;
- this.passwordEncoder = passwordEncoder;
- }
+
/**
* Method to get a user by username from the database.
--
GitLab
From e3b9a49f2fb5319eda22243a4079fa5a6c9adcb7 Mon Sep 17 00:00:00 2001
From: BiggestGuz <Diblopro@gmail.com>
Date: Mon, 29 Apr 2024 10:57:19 +0200
Subject: [PATCH 7/7] All args constructor fix in user service test
---
.../systemutvikling/sparesti/service/UserServiceTest.java | 3 ++-
1 file changed, 2 insertions(+), 1 deletion(-)
diff --git a/src/test/java/idatt2106/systemutvikling/sparesti/service/UserServiceTest.java b/src/test/java/idatt2106/systemutvikling/sparesti/service/UserServiceTest.java
index 2bbacc9..3ee5fe2 100644
--- a/src/test/java/idatt2106/systemutvikling/sparesti/service/UserServiceTest.java
+++ b/src/test/java/idatt2106/systemutvikling/sparesti/service/UserServiceTest.java
@@ -55,7 +55,8 @@ public class UserServiceTest {
public void setup() {
MockitoAnnotations.openMocks(this);
passwordEncoder = mock(PasswordEncoder.class);
- userService = new UserService(userRepository, customerService, jwtService, accountService, milestoneService, milestoneLogService, passwordEncoder);
+ userService = new UserService(passwordEncoder, customerService, accountService, jwtService, milestoneService, milestoneLogService, userRepository, null, null, null, null, null);
+ when(jwtService.extractUsernameFromToken(anyString())).thenReturn("testUser");
when(customerService.hasTwoAccounts(anyString())).thenReturn(true);
when(milestoneLogService.getMilestoneLogsByUsername(anyString())).thenReturn(Collections.emptyList()); // return an empty list
}
--
GitLab