AlexVV007 · AlexVV007 · Oct 16, 2025
diff --git a/README.md b/README.md
@@ -1,3 +1,3 @@
 # REST API  using Spring Boot 
 
- ## task 1
+ ## task 2
diff --git a/pom.xml b/pom.xml
@@ -49,6 +49,11 @@
 			<artifactId>spring-boot-starter-test</artifactId>
 			<scope>test</scope>
 		</dependency>
+
+		<dependency>
+			<groupId>com.fasterxml.jackson.datatype</groupId>
+			<artifactId>jackson-datatype-jsr310</artifactId>
+		</dependency>
 	</dependencies>
 
 	<build>

diff --git a/src/main/java/task/repository/TaskRepository.java b/src/main/java/task/repository/TaskRepository.java
@@ -11,6 +11,7 @@ public interface TaskRepository {
     public List<Task> findByUserIdAndIsDeleteFalse(Long userId);
     public List<Task> findByUserIdAndIsCompleteFalseAndIsDeleteFalse(Long userId) ;
     public Task save(Task task) ;
+    public Optional<Task> findByIdAndIsDeleteFalse(Long taskId);
     public void markAsDeleted(Long taskId);
 
 }
diff --git a/src/main/java/task/repository/impl/TaskRepositoryImpl.java b/src/main/java/task/repository/impl/TaskRepositoryImpl.java
@@ -47,6 +47,11 @@ public Task save(Task task) {
         return task;
     }
     @Override
+    public Optional<Task> findByIdAndIsDeleteFalse(Long taskId) {
+        Task task = tasks.get(taskId);
+        return (task != null && !task.getIsDelete()) ? Optional.of(task) : Optional.empty();
+    }
+    @Override
     public void markAsDeleted(Long taskId) {
         Optional.ofNullable(tasks.get(taskId))
                 .ifPresent(task -> task.setIsDelete(true));

diff --git a/src/test/java/task/controller/NotificationControllerTest.java b/src/test/java/task/controller/NotificationControllerTest.java
@@ -0,0 +1,96 @@
+package task.controller;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.fasterxml.jackson.datatype.jsr310.JavaTimeModule;
+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.http.MediaType;
+import org.springframework.test.web.servlet.MockMvc;
+import org.springframework.test.web.servlet.setup.MockMvcBuilders;
+import task.model.Notification;
+import task.service.NotificationService;
+
+import java.util.List;
+
+import static org.mockito.Mockito.*;
+import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.*;
+import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.*;
+
+class NotificationControllerTest {
+
+    private MockMvc mockMvc;
+    private ObjectMapper objectMapper;
+
+    @Mock
+    private NotificationService notificationService;
+
+    @InjectMocks
+    private NotificationController notificationController;
+
+    private Notification notification;
+
+    @BeforeEach
+    void setUp() {
+        MockitoAnnotations.openMocks(this);
+        mockMvc = MockMvcBuilders.standaloneSetup(notificationController).build();
+        objectMapper = new ObjectMapper();
+        objectMapper.registerModule(new JavaTimeModule());
+
+        notification = Notification.builder()
+                .notificationId(1L)
+                .text("New task available")
+                .userId(1L)
+                .taskId(2L)
+                .isRead(false)
+                .build();
+    }
+
+    @Test
+    void getAllNotifications_WhenExist_ReturnsOkAndList() throws Exception {
+        when(notificationService.getAllNotifications()).thenReturn(List.of(notification));
+
+        mockMvc.perform(get("/api/notifications"))
+                .andExpect(status().isOk())
+                .andExpect(jsonPath("$[0].text").value("New task available"));
+
+        verify(notificationService).getAllNotifications();
+    }
+
+    @Test
+    void getUserNotifications_ValidUserId_ReturnsOkAndList() throws Exception {
+        when(notificationService.getUserNotifications(1L)).thenReturn(List.of(notification));
+
+        mockMvc.perform(get("/api/notifications/user/1"))
+                .andExpect(status().isOk())
+                .andExpect(jsonPath("$[0].userId").value(1));
+
+        verify(notificationService).getUserNotifications(1L);
+    }
+
+    @Test
+    void getUserNotificationsUnread_UnreadExist_ReturnsOkAndUnreadList() throws Exception {
+        when(notificationService.getUserNotificationsUnread(1L)).thenReturn(List.of(notification));
+
+        mockMvc.perform(get("/api/notifications/user/1/unread"))
+                .andExpect(status().isOk())
+                .andExpect(jsonPath("$[0].isRead").value(false));
+
+        verify(notificationService).getUserNotificationsUnread(1L);
+    }
+
+    @Test
+    void createNotification_ValidData_ReturnsCreated() throws Exception {
+        when(notificationService.createNotification(any(Notification.class))).thenReturn(notification);
+
+        mockMvc.perform(post("/api/notifications")
+                        .contentType(MediaType.APPLICATION_JSON)
+                        .content(objectMapper.writeValueAsString(notification)))
+                .andExpect(status().isCreated())
+                .andExpect(jsonPath("$.text").value("New task available"));
+
+        verify(notificationService).createNotification(any(Notification.class));
+    }
+}
diff --git a/src/test/java/task/controller/TaskControllerTest.java b/src/test/java/task/controller/TaskControllerTest.java
@@ -0,0 +1,96 @@
+package task.controller;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+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.http.MediaType;
+import org.springframework.test.web.servlet.MockMvc;
+import org.springframework.test.web.servlet.setup.MockMvcBuilders;
+import task.model.Task;
+import task.service.TaskService;
+
+import java.time.LocalDateTime;
+import java.util.List;
+
+import static org.mockito.Mockito.*;
+import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.*;
+import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.*;
+import com.fasterxml.jackson.datatype.jsr310.JavaTimeModule;
+
+class TaskControllerTest {
+
+    private MockMvc mockMvc;
+    private ObjectMapper objectMapper;
+
+    @Mock
+    private TaskService taskService;
+
+    @InjectMocks
+    private TaskController taskController;
+
+    private Task task;
+
+    @BeforeEach
+    void setUp() {
+        MockitoAnnotations.openMocks(this);
+        mockMvc = MockMvcBuilders.standaloneSetup(taskController).build();
+        objectMapper = new ObjectMapper();
+
+        objectMapper.registerModule(new JavaTimeModule());
+
+        task = Task.builder()
+                .taskId(1L)
+                .taskText("Sample Task")
+                .userId(1L)
+                .createDate(LocalDateTime.now())
+                .build();
+    }
+
+    @Test
+    void getAllTasks_WhenTasksExist_ReturnsOkAndList() throws Exception {
+        when(taskService.getAllTasks()).thenReturn(List.of(task));
+
+        mockMvc.perform(get("/api/tasks"))
+                .andExpect(status().isOk())
+                .andExpect(jsonPath("$[0].taskText").value("Sample Task"));
+
+        verify(taskService).getAllTasks();
+    }
+
+    @Test
+    void getUserTasks_ValidUserId_ReturnsOk() throws Exception {
+        when(taskService.getUserTasks(1L)).thenReturn(List.of(task));
+
+        mockMvc.perform(get("/api/tasks/user/1"))
+                .andExpect(status().isOk())
+                .andExpect(jsonPath("$[0].userId").value(1));
+
+        verify(taskService).getUserTasks(1L);
+    }
+
+    @Test
+    void createTask_ValidTask_ReturnsCreated() throws Exception {
+        when(taskService.createTask(any(Task.class))).thenReturn(task);
+
+        mockMvc.perform(post("/api/tasks")
+                        .contentType(MediaType.APPLICATION_JSON)
+                        .content(objectMapper.writeValueAsString(task)))
+                .andExpect(status().isCreated())
+                .andExpect(jsonPath("$.taskText").value("Sample Task"));
+
+        verify(taskService).createTask(any(Task.class));
+    }
+
+    @Test
+    void deleteTask_ValidId_ReturnsNoContent() throws Exception {
+        doNothing().when(taskService).deleteTask(1L);
+
+        mockMvc.perform(delete("/api/tasks/1"))
+                .andExpect(status().isNoContent());
+
+        verify(taskService).deleteTask(1L);
+    }
+}
diff --git a/src/test/java/task/controller/UserControllerTest.java b/src/test/java/task/controller/UserControllerTest.java
@@ -0,0 +1,93 @@
+package task.controller;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.mockito.Mock;
+import org.mockito.InjectMocks;
+import org.mockito.MockitoAnnotations;
+import org.springframework.http.MediaType;
+import org.springframework.test.web.servlet.MockMvc;
+import org.springframework.test.web.servlet.setup.MockMvcBuilders;
+import task.model.User;
+import task.service.UserService;
+
+import java.util.List;
+import java.util.Optional;
+
+import static org.mockito.Mockito.*;
+import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.*;
+import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.*;
+
+class UserControllerTest {
+
+    private MockMvc mockMvc;
+
+    @Mock
+    private UserService userService;
+
+    @InjectMocks
+    private UserController userController;
+
+    private ObjectMapper objectMapper;
+    private User user;
+
+    @BeforeEach
+    void setUp() {
+        MockitoAnnotations.openMocks(this);
+        mockMvc = MockMvcBuilders.standaloneSetup(userController).build();
+        objectMapper = new ObjectMapper();
+
+        user = User.builder()
+                .userId(1L)
+                .login("testLogin")
+                .userName("testUser")
+                .email("test@mail.com")
+                .build();
+    }
+
+    @Test
+    void getAllUsers_WhenUsersExist_ReturnsOkAndUserList() throws Exception {
+        when(userService.getAllUsers()).thenReturn(List.of(user));
+
+        mockMvc.perform(get("/api/users"))
+                .andExpect(status().isOk())
+                .andExpect(jsonPath("$[0].userName").value("testUser"));
+
+        verify(userService).getAllUsers();
+    }
+
+    @Test
+    void register_ValidUser_ReturnsCreated() throws Exception {
+        when(userService.register(any(User.class))).thenReturn(user);
+
+        mockMvc.perform(post("/api/users")
+                        .contentType(MediaType.APPLICATION_JSON)
+                        .content(objectMapper.writeValueAsString(user)))
+                .andExpect(status().isCreated())
+                .andExpect(jsonPath("$.login").value("testLogin"));
+
+        verify(userService).register(any(User.class));
+    }
+
+    @Test
+    void getUserById_ExistingId_ReturnsOkAndUser() throws Exception {
+        when(userService.getUserById(1L)).thenReturn(Optional.of(user));
+
+        mockMvc.perform(get("/api/users/1"))
+                .andExpect(status().isOk())
+                .andExpect(jsonPath("$.userName").value("testUser"));
+
+        verify(userService).getUserById(1L);
+    }
+
+    @Test
+    void getUserById_NonExistingId_ReturnsNotFound() throws Exception {
+        when(userService.getUserById(99L)).thenReturn(Optional.empty());
+
+        mockMvc.perform(get("/api/users/99"))
+                .andExpect(status().isNotFound());
+
+        verify(userService).getUserById(99L);
+    }
+}