Merge remote-tracking branch 'origin/main' into cupboard-component

# Conflicts:
#	ufund-api/data/cupboard.json
#	ufund-ui/src/app/app.module.ts

3 files changed, 370 insertions, 82 deletions

diff --git a/ufund-api/src/test/java/com/ufund/api/ufundapi/controller/AuthControllerTest.java b/ufund-api/src/test/java/com/ufund/api/ufundapi/controller/AuthControllerTest.java
new file mode 100644
index 0000000..3d4637d
--- /dev/null
+++ b/ufund-api/src/test/java/com/ufund/api/ufundapi/controller/AuthControllerTest.java
@@ -0,0 +1,104 @@
+package com.ufund.api.ufundapi.controller;
+
+import java.io.IOException;
+import java.util.Map;
+import static java.util.Map.entry;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import static org.mockito.ArgumentMatchers.any;
+import org.mockito.Mockito;
+import static org.mockito.Mockito.doThrow;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.RequestMapping;
+
+import com.ufund.api.ufundapi.service.AuthService;
+
+@RequestMapping("auth")
+public class AuthControllerTest {
+
+    private AuthController authController;
+    private AuthService mockAuthService;
+    private Map<String, String> authMap;
+
+    @BeforeEach
+    private void setupAuthController() {
+        mockAuthService = mock(AuthService.class);
+        authController = new AuthController(mockAuthService);
+
+        authMap = Map.ofEntries(
+                entry("Bob", "123")
+        );
+    }
+
+    @Test
+    public void testLogin() throws IllegalAccessException, IOException {
+        // Setup
+        String key = "123";
+
+        // Mock
+        when(mockAuthService.login(any(), any())).thenReturn(key);
+
+        // Invoke
+        ResponseEntity<String> response = authController.login(authMap);
+
+        // Analyze
+        assertEquals(HttpStatus.OK, response.getStatusCode());
+        assertEquals(key, response.getBody());
+    }
+
+    @Test
+    public void testLoginUnauthorized() throws IllegalAccessException, IOException {
+        // Mock
+        when(mockAuthService.login(any(), any())).thenThrow(IllegalAccessException.class);
+
+        // Invoke
+        ResponseEntity<String> response = authController.login(authMap);
+
+        // Analyze
+        assertEquals(HttpStatus.UNAUTHORIZED, response.getStatusCode());
+    }
+
+    @Test
+    public void testLoginIOException() throws IllegalAccessException, IOException {
+        // Mock
+        when(mockAuthService.login(any(), any())).thenThrow(IOException.class);
+
+        // Invoke
+        ResponseEntity<String> response = authController.login(authMap);
+
+        // Analyze
+        assertEquals(HttpStatus.INTERNAL_SERVER_ERROR, response.getStatusCode());
+    }
+
+    @Test
+    public void testLogout() throws IllegalAccessException, IOException {
+        // Setup
+        String key = "123";
+
+        // Invoke
+        ResponseEntity<Object> response = authController.logout(key);
+
+        // Analyze
+        assertEquals(HttpStatus.OK, response.getStatusCode());
+    }
+
+    @Test
+    public void testLogoutIOException() throws IllegalAccessException, IOException {
+        // Setup
+        String key = "123";
+
+        // Mock
+        doThrow(new IOException()).when(mockAuthService).logout(key);
+
+        // Invoke
+        ResponseEntity<Object> response = authController.logout(key);
+
+        // Analyze
+        assertEquals(HttpStatus.INTERNAL_SERVER_ERROR, response.getStatusCode());
+    }
+}
diff --git a/ufund-api/src/test/java/com/ufund/api/ufundapi/controller/CupboardControllerTest.java b/ufund-api/src/test/java/com/ufund/api/ufundapi/controller/CupboardControllerTest.java
index 04ce41d..100bf09 100644
--- a/ufund-api/src/test/java/com/ufund/api/ufundapi/controller/CupboardControllerTest.java
+++ b/ufund-api/src/test/java/com/ufund/api/ufundapi/controller/CupboardControllerTest.java
@@ -1,42 +1,86 @@
 package com.ufund.api.ufundapi.controller;
 
-import com.ufund.api.ufundapi.model.Need;
-import com.ufund.api.ufundapi.persistence.CupboardFileDao;
-import org.junit.jupiter.api.BeforeEach;
-import org.junit.jupiter.api.Test;
-import org.springframework.http.HttpStatus;
-
 import java.io.IOException;
+import java.util.Map;
+import static java.util.Map.entry;
 
-import static org.junit.jupiter.api.Assertions.*;
+import static org.junit.jupiter.api.Assertions.assertArrayEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNull;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.when;
+import org.springframework.http.HttpStatus;
+
+import com.ufund.api.ufundapi.DuplicateKeyException;
+import com.ufund.api.ufundapi.model.Need;
+import com.ufund.api.ufundapi.model.Need.GoalType;
+import com.ufund.api.ufundapi.service.CupboardService;
 
 public class CupboardControllerTest {
     private CupboardController cupboardController;
-    private CupboardFileDao mockCupboardDAO;
+    private CupboardService mockCupboardService;
 
     @BeforeEach
     public void setupCupboardDAO() {
-        mockCupboardDAO = mock(CupboardFileDao.class);
-        cupboardController = new CupboardController(mockCupboardDAO);
+        mockCupboardService = mock(CupboardService.class);
+        cupboardController = new CupboardController(mockCupboardService);
     }
 
     @Test
-    public void createNeed() throws IOException {
-        var need = new Need("Name", 1, 100, Need.GoalType.MONETARY);
-        when(mockCupboardDAO.createNeed(need)).thenReturn(need);
+    public void createNeed() throws IOException, DuplicateKeyException {
+        String name = "Test";
+        int maxGoal = 100;
+        GoalType type = Need.GoalType.MONETARY;
+        var need = new Need(name, type, maxGoal);
+        when(mockCupboardService.createNeed(name, maxGoal, type)).thenReturn(need);
+
 
-        var res = cupboardController.createNeed(need);
+        Map<String, String> needMap = Map.ofEntries(
+                entry("name", "Test"),
+                entry("maxGoal", "100"),
+                entry("goalType", "MONETARY")
+        );
+
+        var res = cupboardController.createNeed(needMap);
 
         assertEquals(HttpStatus.OK, res.getStatusCode());
         assertEquals(need, res.getBody());
     }
 
     @Test
-    public void getNeeds() {
+    public void createNeedBadMaxGoal() throws IOException, DuplicateKeyException {
+        when(mockCupboardService.createNeed("Name", -100, Need.GoalType.MONETARY)).thenThrow(new IllegalArgumentException());
+
+        Map<String, String> needMap = Map.ofEntries(
+                entry("name", "Name"),
+                entry("maxGoal", "-100"),
+                entry("goalType", "MONETARY"));
+
+        var res = cupboardController.createNeed(needMap);
+
+        assertEquals(HttpStatus.UNPROCESSABLE_ENTITY, res.getStatusCode());
+    }
+
+    @Test
+    public void createNeedIOException() throws IOException, DuplicateKeyException {
+        when(mockCupboardService.createNeed("Name", 100, Need.GoalType.MONETARY)).thenThrow(new IOException());
+
+        Map<String, String> needMap = Map.ofEntries(
+                entry("name", "Name"),
+                entry("maxGoal", "100"),
+                entry("goalType", "MONETARY"));
+
+        var res = cupboardController.createNeed(needMap);
+
+        assertEquals(HttpStatus.INTERNAL_SERVER_ERROR, res.getStatusCode());
+    }
+
+    @Test
+    public void getNeeds() throws IOException {
         var need = new Need("Name", 1, 100, Need.GoalType.MONETARY);
-        when(mockCupboardDAO.getNeeds()).thenReturn(new Need[]{need});
+        when(mockCupboardService.getNeeds()).thenReturn(new Need[]{need});
 
         var res = cupboardController.getNeeds();
 
@@ -45,8 +89,17 @@ public class CupboardControllerTest {
     }
 
     @Test
-    public void getNeedsEmpty() {
-        when(mockCupboardDAO.getNeeds()).thenReturn(new Need[]{});
+    public void getNeedsIOException() throws IOException {
+        when(mockCupboardService.getNeeds()).thenThrow(new IOException());
+
+        var res = cupboardController.getNeeds();
+
+        assertEquals(HttpStatus.INTERNAL_SERVER_ERROR, res.getStatusCode());
+    }
+
+    @Test
+    public void getNeedsEmpty() throws IOException {
+        when(mockCupboardService.getNeeds()).thenReturn(new Need[]{});
 
         var res = cupboardController.getNeeds();
 
@@ -55,9 +108,9 @@ public class CupboardControllerTest {
     }
 
     @Test
-    public void searchNeeds() {
+    public void searchNeeds() throws IOException {
         var need = new Need("Name", 1, 100, Need.GoalType.MONETARY);
-        when(mockCupboardDAO.findNeeds("Na")).thenReturn(new Need[]{need});
+        when(mockCupboardService.searchNeeds("Na")).thenReturn(new Need[]{need});
 
         var res = cupboardController.searchNeeds("Na");
 
@@ -66,8 +119,17 @@ public class CupboardControllerTest {
     }
 
     @Test
-    public void searchNeedsEmpty() {
-        when(mockCupboardDAO.findNeeds("Na")).thenReturn(new Need[]{});
+    public void searchNeedsIOException() throws IOException {
+        when(mockCupboardService.searchNeeds("Na")).thenThrow(new IOException());
+
+        var res = cupboardController.searchNeeds("Na");
+
+        assertEquals(HttpStatus.INTERNAL_SERVER_ERROR, res.getStatusCode());
+    }
+
+    @Test
+    public void searchNeedsEmpty() throws IOException {
+        when(mockCupboardService.searchNeeds("Na")).thenReturn(new Need[]{});
 
         var res = cupboardController.searchNeeds("Na");
 
@@ -76,9 +138,9 @@ public class CupboardControllerTest {
     }
 
     @Test
-    public void getNeed() {
+    public void getNeed() throws IOException {
         var need = new Need("Name", 1, 100, Need.GoalType.MONETARY);
-        when(mockCupboardDAO.getNeed(need.getId())).thenReturn(need);
+        when(mockCupboardService.getNeed(need.getId())).thenReturn(need);
 
         var res = cupboardController.getNeed(need.getId());
 
@@ -87,9 +149,19 @@ public class CupboardControllerTest {
     }
 
     @Test
-    public void getNeedFail() {
+    public void getNeedIOException() throws IOException {
+        var need = new Need("Name", 1, 100, Need.GoalType.MONETARY);
+        when(mockCupboardService.getNeed(need.getId())).thenThrow(new IOException());
+
+        var res = cupboardController.getNeed(need.getId());
+
+        assertEquals(HttpStatus.INTERNAL_SERVER_ERROR, res.getStatusCode());
+    }
+
+    @Test
+    public void getNeedFail() throws IOException {
         var need = new Need("Name", 1, 100, Need.GoalType.MONETARY);
-        when(mockCupboardDAO.getNeed(need.getId())).thenReturn(null);
+        when(mockCupboardService.getNeed(need.getId())).thenReturn(null);
 
         var res = cupboardController.getNeed(need.getId());
 
@@ -100,19 +172,29 @@ public class CupboardControllerTest {
     @Test
     public void updateNeeds() throws IOException {
         var need = new Need("Name", 1, 100, Need.GoalType.MONETARY);
-        when(mockCupboardDAO.updateNeed(need)).thenReturn(need);
+        when(mockCupboardService.updateNeed(need, 1)).thenReturn(need);
 
-        var res = cupboardController.updateNeed(need);
+        var res = cupboardController.updateNeed(need, 1);
 
         assertEquals(HttpStatus.OK, res.getStatusCode());
         assertEquals(need, res.getBody());
     }
 
     @Test
+    public void updateNeedsIOException() throws IOException {
+        var need = new Need("Name", 1, 100, Need.GoalType.MONETARY);
+        when(mockCupboardService.updateNeed(need, 1)).thenThrow(new IOException());
+
+        var res = cupboardController.updateNeed(need, 1);
+
+        assertEquals(HttpStatus.INTERNAL_SERVER_ERROR, res.getStatusCode());
+    }
+
+    @Test
     public void deleteNeed() throws IOException {
         var need = new Need("Name", 1, 100, Need.GoalType.MONETARY);
-        when(mockCupboardDAO.getNeed(1)).thenReturn(need);
-        when(mockCupboardDAO.deleteNeed(1)).thenReturn(true);
+        when(mockCupboardService.getNeed(1)).thenReturn(need);
+        when(mockCupboardService.deleteNeed(1)).thenReturn(true);
 
         var res = cupboardController.deleteNeed(1);
 
@@ -121,11 +203,22 @@ public class CupboardControllerTest {
 
     @Test
     public void deleteNeedFail() throws IOException {
-        when(mockCupboardDAO.getNeed(1)).thenReturn(null);
-        when(mockCupboardDAO.deleteNeed(1)).thenReturn(false);
+        when(mockCupboardService.getNeed(1)).thenReturn(null);
+        when(mockCupboardService.deleteNeed(1)).thenReturn(false);
 
         var res = cupboardController.deleteNeed(1);
 
         assertEquals(HttpStatus.NOT_FOUND, res.getStatusCode());
     }
+
+    @Test
+    public void deleteNeedIOException() throws IOException {
+        var need = new Need("Name", 1, 100, Need.GoalType.MONETARY);
+        when(mockCupboardService.getNeed(1)).thenReturn(need);
+        when(mockCupboardService.deleteNeed(1)).thenThrow(new IOException());
+
+        var res = cupboardController.deleteNeed(1);
+
+        assertEquals(HttpStatus.INTERNAL_SERVER_ERROR, res.getStatusCode());
+    }
 }
diff --git a/ufund-api/src/test/java/com/ufund/api/ufundapi/controller/UserControllerTest.java b/ufund-api/src/test/java/com/ufund/api/ufundapi/controller/UserControllerTest.java
index 681f47c..b6367ad 100644
--- a/ufund-api/src/test/java/com/ufund/api/ufundapi/controller/UserControllerTest.java
+++ b/ufund-api/src/test/java/com/ufund/api/ufundapi/controller/UserControllerTest.java
@@ -1,8 +1,12 @@
 package com.ufund.api.ufundapi.controller;
 
 import java.io.IOException;
+import java.security.InvalidParameterException;
+import java.util.Map;
+import static java.util.Map.entry;
 
 import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Tag;
 import org.junit.jupiter.api.Test;
@@ -12,82 +16,111 @@ import static org.mockito.Mockito.when;
 import org.springframework.http.HttpStatus;
 import org.springframework.http.ResponseEntity;
 
+import com.ufund.api.ufundapi.DuplicateKeyException;
 import com.ufund.api.ufundapi.model.User;
-import com.ufund.api.ufundapi.persistence.UserFileDAO;
+import com.ufund.api.ufundapi.model.UserAuth;
+import com.ufund.api.ufundapi.service.AuthService;
+import com.ufund.api.ufundapi.service.UserService;
 
 @Tag("Controller-tier")
 public class UserControllerTest {
     private UserController userController;
-    private UserFileDAO mockUserDAO;
+    private AuthService mockAuthService;
+    private UserService mockUserService;
+    private Map<String, String> userMap;
 
     @BeforeEach
     public void setupUserController() {
-        mockUserDAO = mock(UserFileDAO.class);
-        userController = new UserController(mockUserDAO);
-
+        mockUserService = mock(UserService.class);
+        mockAuthService = mock(AuthService.class);
+        userController = new UserController(mockUserService, mockAuthService);
+        userMap = Map.ofEntries(
+                entry("username", "Test"),
+                entry("password", "Pass")
+        );
     }
 
     @Test
     public void testGetUser() throws IOException { // getUser may throw IOException
         // Setup
         String username = "Test";
-        User user = new User(username);
+        User user = User.create(username, "pass");
+        String key = UserAuth.generate(username).getKey(    );
         // When the same id is passed in, our mock User DAO will return the User object
-        when(mockUserDAO.getUser(username)).thenReturn(user);
+        when(mockUserService.getUser(username)).thenReturn(user);
+        
 
         // Invoke
-        ResponseEntity<User> response = userController.getUser(username);
+        ResponseEntity<User> response = userController.getUser(username, key);
 
         // Analyze
         assertEquals(HttpStatus.OK, response.getStatusCode());
-        assertEquals(user, response.getBody());
+        assertNotNull(response.getBody());
+        assertEquals(user.getUsername(), response.getBody().getUsername());
     }
 
     @Test
     public void testGetUserNotFound() throws Exception { // createUser may throw IOException
         // Setup
         String username = "Test";
-        // When the same id is passed in, our mock User DAO will return null, simulating
+        String key = UserAuth.generate(username).getKey();
+        // When the same id is passed in, our mock User service will return null, simulating
         // no User found
-        when(mockUserDAO.getUser(username)).thenReturn(null);
+        when(mockUserService.getUser(username)).thenReturn(null);
+        
 
         // Invoke
-        ResponseEntity<User> response = userController.getUser(username);
+        ResponseEntity<User> response = userController.getUser(username, key);
 
         // Analyze
         assertEquals(HttpStatus.NOT_FOUND, response.getStatusCode());
     }
 
     @Test
+    public void testGetUserUnauthorized() throws Exception { // createUser may throw IOException
+        // Setup
+        String username = "Test";
+        String key = UserAuth.generate(username).getKey();
+        // When getUser is called on the Mock User service, throw an IOException
+        // doThrow(new IllegalAccessException()).when(mockUserService).getUser(username);
+        doThrow(new IllegalAccessException()).when(mockAuthService).authenticate(username, key);
+
+        // Invoke
+        ResponseEntity<User> response = userController.getUser(username, key);
+
+        // Analyze
+        assertEquals(HttpStatus.UNAUTHORIZED, response.getStatusCode());
+    }
+
+    @Test
     public void testGetUserHandleException() throws Exception { // createUser may throw IOException
         // Setup
         String username = "Test";
-        // When getUser is called on the Mock User DAO, throw an IOException
-        doThrow(new IOException()).when(mockUserDAO).getUser(username);
+        String key = UserAuth.generate(username).getKey();
+        // When getUser is called on the Mock User service, throw an IOException
+        doThrow(new IOException()).when(mockUserService).getUser(username);
 
         // Invoke
-        ResponseEntity<User> response = userController.getUser(username);
+        ResponseEntity<User> response = userController.getUser(username, key);
 
         // Analyze
         assertEquals(HttpStatus.INTERNAL_SERVER_ERROR, response.getStatusCode());
     }
 
-    /*****************************************************************
-     * The following tests will fail until all userController methods
-     * are implemented.
-     ****************************************************************/
-
     @Test
-    public void testCreateUser() throws IOException { // createUser may throw IOException
+    public void testCreateUser() throws IOException, DuplicateKeyException { // createUser may throw IOException
         // Setup
         String username = "Test";
-        User user = new User(username);
+        String password = "Pass";
+        User user = User.create(username, "pass");
         // when createUser is called, return true simulating successful
         // creation and save
-        when(mockUserDAO.createUser(user)).thenReturn(user);
+        when(mockUserService.createUser(username, password)).thenReturn(user);
+
+                
 
         // Invoke
-        ResponseEntity<User> response = userController.createUser(user);
+        ResponseEntity<User> response = userController.createUser(userMap);
 
         // Analyze
         assertEquals(HttpStatus.CREATED, response.getStatusCode());
@@ -95,32 +128,52 @@ public class UserControllerTest {
     }
 
     @Test
-    public void testCreateUserFailed() throws IOException { // createUser may throw IOException
+    public void testCreateUserFailed() throws IOException, DuplicateKeyException { // createUser may throw IOException
         // Setup
         String username = "Test";
-        User user = new User(username);
+        String password = "Pass";
         // when createUser is called, return false simulating failed
         // creation and save
-        when(mockUserDAO.createUser(user)).thenReturn(null);
+        when(mockUserService.createUser(username, password)).thenReturn(null);
+
+        
 
         // Invoke
-        ResponseEntity<User> response = userController.createUser(user);
+        ResponseEntity<User> response = userController.createUser(userMap);
 
         // Analyze
         assertEquals(HttpStatus.CONFLICT, response.getStatusCode());
     }
 
     @Test
-    public void testCreateUserHandleException() throws IOException { // createUser may throw IOException
+    public void testCreateUserDuplicate() throws IOException, DuplicateKeyException { // createUser may throw IOException
         // Setup
         String username = "Test";
-        User user = new User(username);
+        String password = "Pass";
+        // when createUser is called, return false simulating failed
+        // creation and save
+        when(mockUserService.createUser(username, password)).thenThrow(DuplicateKeyException.class);
 
-        // When createUser is called on the Mock User DAO, throw an IOException
-        doThrow(new IOException()).when(mockUserDAO).createUser(user);
+        // Invoke
+        ResponseEntity<User> response = userController.createUser(userMap);
+
+        // Analyze
+        assertEquals(HttpStatus.CONFLICT, response.getStatusCode());
+    }
+
+    @Test
+    public void testCreateUserHandleException() throws IOException, DuplicateKeyException { // createUser may throw IOException
+        // Setup
+        String username = "Test";
+        String password = "Pass";
+
+        // When createUser is called on the Mock User service, throw an IOException
+        doThrow(new IOException()).when(mockUserService).createUser(username, password);
+
+        
 
         // Invoke
-        ResponseEntity<User> response = userController.createUser(user);
+        ResponseEntity<User> response = userController.createUser(userMap);
 
         // Analyze
         assertEquals(HttpStatus.INTERNAL_SERVER_ERROR, response.getStatusCode());
@@ -130,13 +183,14 @@ public class UserControllerTest {
     public void testUpdateUser() throws IOException { // updateUser may throw IOException
         // Setup
         String username = "Test";
-        User user = new User("Bob");
+        User user = User.create(username, "pass");
+        String key = UserAuth.generate(username).getKey();
         // when updateUser is called, return true simulating successful
         // update and save
-        when(mockUserDAO.updateUser(user, username)).thenReturn(user);
+        when(mockUserService.updateUser(user, username)).thenReturn(user);
 
         // Invoke
-        ResponseEntity<User> response = userController.updateUser(user, username);
+        ResponseEntity<User> response = userController.updateUser(user, username, key);
 
         // Analyze
         assertEquals(HttpStatus.OK, response.getStatusCode());
@@ -147,42 +201,62 @@ public class UserControllerTest {
     public void testUpdateUserFailed() throws IOException { // updateUser may throw IOException
         // Setup
         String username = "Test";
-        User user = new User("Bob");
+        User user = User.create(username, "pass");
+        String key = UserAuth.generate(username).getKey();
         // when updateUser is called, return true simulating successful
         // update and save
-        when(mockUserDAO.updateUser(user, username)).thenReturn(null);
+        when(mockUserService.updateUser(user, username)).thenReturn(null);
 
         // Invoke
-        ResponseEntity<User> response = userController.updateUser(user, username);
+        ResponseEntity<User> response = userController.updateUser(user, username, key);
 
         // Analyze
         assertEquals(HttpStatus.NOT_FOUND, response.getStatusCode());
     }
 
     @Test
-    public void testUpdateUserHandleException() throws IOException { // updateUser may throw IOException
+    public void testUpdateUserInvalidParameter() throws IOException { // updateUser may throw IOException
         // Setup
         String username = "Test";
-        User user = new User("Bob");
+        User user = User.create(username, "pass");
+        String key = UserAuth.generate(username).getKey();
         // When updateUser is called on the Mock User DAO, throw an IOException
-        doThrow(new IOException()).when(mockUserDAO).updateUser(user, username);
+        doThrow(new IOException()).when(mockUserService).updateUser(user, username);
 
         // Invoke
-        ResponseEntity<User> response = userController.updateUser(user, username);
+        ResponseEntity<User> response = userController.updateUser(user, username, key);
 
         // Analyze
         assertEquals(HttpStatus.INTERNAL_SERVER_ERROR, response.getStatusCode());
     }
 
     @Test
+    public void testUpdateUserUnauthorized() throws IOException, IllegalAccessException { // updateUser may throw IOException
+        // Setup
+        String username = "Test";
+        User user = User.create(username, "pass");
+        String key = UserAuth.generate(username).getKey();
+        // When updateUser is called on the Mock User service, throw a Invalid Parameter exception
+        // exception
+        doThrow(new IllegalAccessException()).when(mockAuthService).authenticate(username, key);
+
+        // Invoke
+        ResponseEntity<User> response = userController.updateUser(user, username, key);
+
+        // Analyze
+        assertEquals(HttpStatus.UNAUTHORIZED, response.getStatusCode());
+    }
+
+    @Test
     public void testDeleteUser() throws IOException { // deleteUser may throw IOException
         // Setup
         String username = "Test";
+        String key = UserAuth.generate(username).getKey();
         // when deleteUser is called return true, simulating successful deletion
-        when(mockUserDAO.deleteUser(username)).thenReturn(true);
+        when(mockUserService.deleteUser(username)).thenReturn(true);
 
         // Invoke
-        ResponseEntity<User> response = userController.deleteUser(username);
+        ResponseEntity<Boolean> response = userController.deleteUser(username, key);
 
         // Analyze
         assertEquals(HttpStatus.OK, response.getStatusCode());
@@ -192,11 +266,12 @@ public class UserControllerTest {
     public void testDeleteUserNotFound() throws IOException { // deleteUser may throw IOException
         // Setup
         String username = "Test";
+        String key = UserAuth.generate(username).getKey();
         // when deleteUser is called return false, simulating failed deletion
-        when(mockUserDAO.deleteUser(username)).thenReturn(false);
+        when(mockUserService.deleteUser(username)).thenReturn(false);
 
         // Invoke
-        ResponseEntity<User> response = userController.deleteUser(username);
+        ResponseEntity<Boolean> response = userController.deleteUser(username, key);
 
         // Analyze
         assertEquals(HttpStatus.NOT_FOUND, response.getStatusCode());
@@ -206,14 +281,30 @@ public class UserControllerTest {
     public void testDeleteUserHandleException() throws IOException { // deleteUser may throw IOException
         // Setup
         String username = "Test";
-        // When deleteUser is called on the Mock User DAO, throw an IOException
-        doThrow(new IOException()).when(mockUserDAO).deleteUser(username);
+        String key = UserAuth.generate(username).getKey();
+        // When deleteUser is called on the Mock User service, throw an IOException
+        doThrow(new IOException()).when(mockUserService).deleteUser(username);
 
         // Invoke
-        ResponseEntity<User> response = userController.deleteUser(username);
+        ResponseEntity<Boolean> response = userController.deleteUser(username, key);
 
         // Analyze
         assertEquals(HttpStatus.INTERNAL_SERVER_ERROR, response.getStatusCode());
     }
 
+    @Test
+    public void testDeleteUserUnauthorized() throws IOException, IllegalAccessException { // deleteUser may throw IOException
+        // Setup
+        String username = "Test";
+        String key = UserAuth.generate(username).getKey();
+        // When deleteUser is called on the Mock User service, throw an IOException
+        doThrow(new IllegalAccessException()).when(mockAuthService).authenticate(username, key);
+
+        // Invoke
+        ResponseEntity<Boolean> response = userController.deleteUser(username, key);
+
+        // Analyze
+        assertEquals(HttpStatus.UNAUTHORIZED, response.getStatusCode());
+    }
+
 }