注册登录，用户等级，社交，动态，新手任务
Change-Id: I1d3183526517fb3c0dab665e0e7547eefa5c9d76
diff --git a/src/test/java/com/example/myproject/controller/CommentControllerTest.java b/src/test/java/com/example/myproject/controller/CommentControllerTest.java
new file mode 100644
index 0000000..9dedd29
--- /dev/null
+++ b/src/test/java/com/example/myproject/controller/CommentControllerTest.java
@@ -0,0 +1,81 @@
+package com.example.myproject.controller;
+
+import com.example.myproject.entity.Comments;
+import com.example.myproject.entity.Users;
+import com.example.myproject.service.CommentService;
+import com.example.myproject.utils.Result;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.mockito.*;
+import org.springframework.beans.factory.annotation.Autowired;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import static org.mockito.Mockito.*;
+import static org.junit.jupiter.api.Assertions.*;
+
+class CommentControllerTest {
+
+ @InjectMocks
+ private CommentController commentController;
+ @Mock
+ private CommentService commentService;
+
+ @Mock
+ private Users mockUser;
+
+ @BeforeEach
+ void setup() {
+ MockitoAnnotations.openMocks(this);
+ }
+
+ // 测试添加评论
+ @Test
+ void addCommentTest() {
+ Long postId = 1L;
+ Comments comment = new Comments();
+ comment.setUserId(1L);
+ comment.setContent("This is a comment");
+ comment.setParentComment(0L);
+ // 模拟服务层的行为
+ doNothing().when(commentService).addComment(eq(postId), eq(comment));
+
+ // 调用控制器的方法
+ String result = commentController.addComment(postId, comment);
+
+ // 验证返回的结果
+ assertEquals("Comment added successfully!", result);
+
+ // 验证服务方法是否被调用
+ verify(commentService, times(1)).addComment(eq(postId), eq(comment));
+ }
+
+ // 测试获取评论
+ @Test
+ void getCommentsByPostIdTest() {
+ Long postId = 1L;
+
+ // 模拟评论数据
+ Map<String, Object> commentData = new HashMap<>();
+ commentData.put("commentId", 1L);
+ commentData.put("content", "This is a comment");
+ commentData.put("userId", 1L);
+ commentData.put("nickname", "user1");
+
+ // 模拟服务层的行为
+ when(commentService.getCommentsByPostId(postId)).thenReturn(List.of(commentData));
+
+ // 调用控制器的方法
+ List<Map<String, Object>> comments = commentController.getCommentsByPostId(postId);
+
+ // 验证返回的评论数据
+ assertEquals(1, comments.size());
+ assertEquals("This is a comment", comments.get(0).get("content"));
+ assertEquals("user1", comments.get(0).get("nickname"));
+
+ // 验证服务方法是否被调用
+ verify(commentService, times(1)).getCommentsByPostId(postId);
+ }
+}
diff --git a/src/test/java/com/example/myproject/controller/DynamicControllerTest.java b/src/test/java/com/example/myproject/controller/DynamicControllerTest.java
new file mode 100644
index 0000000..7392162
--- /dev/null
+++ b/src/test/java/com/example/myproject/controller/DynamicControllerTest.java
@@ -0,0 +1,168 @@
+package com.example.myproject.controller;
+
+import com.example.myproject.controller.DynamicController;
+import com.example.myproject.service.DynamicService;
+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.ResponseEntity;
+
+import java.util.HashMap;
+import java.util.Map;
+
+import static org.mockito.Mockito.*;
+import static org.junit.jupiter.api.Assertions.*;
+
+class DynamicControllerTest {
+
+ @InjectMocks
+ private DynamicController dynamicController;
+
+ @Mock
+ private DynamicService dynamicService;
+
+ @BeforeEach
+ void setup() {
+ MockitoAnnotations.openMocks(this);
+ }
+
+ // 测试创建动态接口
+ @Test
+ void testCreateDynamic() {
+ Long userId = 1L;
+ String content = "This is a test dynamic";
+ Map<String, Object> mockResponse = new HashMap<>();
+ mockResponse.put("dynamicId", 123L);
+ mockResponse.put("message", "动态创建成功");
+
+ // 模拟 dynamicService.createDynamic 返回
+ when(dynamicService.createDynamic(userId, null, content, null)).thenReturn(mockResponse);
+
+ // 调用控制器方法
+ Map<String, Object> responseMap = dynamicController.createDynamic(userId, null, content, null);
+ ResponseEntity<Map<String, Object>> responseEntity = ResponseEntity.ok(responseMap);
+
+ // 验证返回的结果
+ assertEquals(200, responseEntity.getStatusCodeValue());
+ assertEquals("动态创建成功", responseEntity.getBody().get("message"));
+ assertEquals(123L, responseEntity.getBody().get("dynamicId"));
+ }
+
+
+ // 测试删除动态接口
+ @Test
+ void testDeleteDynamic() {
+ Long dynamicId = 1L;
+ // 模拟 dynamicService.deleteDynamic 方法行为
+ doNothing().when(dynamicService).deleteDynamic(dynamicId);
+
+ // 调用控制器方法
+ ResponseEntity<String> response = dynamicController.deleteDynamic(dynamicId);
+
+ // 验证返回的结果
+ assertEquals(200, response.getStatusCodeValue());
+ assertEquals("动态删除成功", response.getBody());
+ }
+
+ // 测试添加评论接口
+ @Test
+ void testAddComment() {
+ Long userId = 1L;
+ Long dynamicId = 1L;
+ Map<String, String> commentContent = new HashMap<>();
+ commentContent.put("content", "This is a test comment");
+
+ Map<String, Object> mockResponse = new HashMap<>();
+ mockResponse.put("comment_id", 101L);
+ mockResponse.put("message", "评论成功");
+
+ // 模拟 dynamicService.addComment 返回
+ when(dynamicService.addComment(userId, dynamicId, "This is a test comment")).thenReturn(mockResponse);
+
+ // 调用控制器方法
+ ResponseEntity<Map<String, Object>> response = dynamicController.addComment(userId, dynamicId, commentContent);
+
+ // 验证返回的结果
+ assertEquals(200, response.getStatusCodeValue());
+ assertEquals("评论成功", response.getBody().get("message"));
+ assertEquals(101L, response.getBody().get("comment_id"));
+ }
+
+ // 测试获取用户动态接口
+ @Test
+ void testGetAllUserDynamics() {
+ Long userId = 1L;
+ Map<String, Object> mockResponse = new HashMap<>();
+ mockResponse.put("status", "success");
+ mockResponse.put("dynamic", "mock_dynamic_data");
+
+ // 模拟 dynamicService.getAllUserDynamics 返回
+ when(dynamicService.getAllUserDynamics(userId)).thenReturn(mockResponse);
+
+ // 调用控制器方法
+ ResponseEntity<Map<String, Object>> response = dynamicController.getAllUserDynamics(userId);
+
+ // 验证返回的结果
+ assertEquals(200, response.getStatusCodeValue());
+ assertEquals("success", response.getBody().get("status"));
+ assertNotNull(response.getBody().get("dynamic"));
+ }
+
+ // 测试获取所有好友动态接口
+ @Test
+ void testGetAllUserAndFriendsDynamics() {
+ Long userId = 1L;
+ Map<String, Object> mockResponse = new HashMap<>();
+ mockResponse.put("status", "success");
+ mockResponse.put("dynamic", "mock_friend_dynamic_data");
+
+ // 模拟 dynamicService.getAllUserAndFriendsDynamics 返回
+ when(dynamicService.getAllUserAndFriendsDynamics(anyList())).thenReturn(mockResponse);
+
+ // 调用控制器方法
+ ResponseEntity<Map<String, Object>> response = dynamicController.getAllUserAndFriendsDynamics(userId);
+
+ // 验证返回的结果
+ assertEquals(200, response.getStatusCodeValue());
+ assertEquals("success", response.getBody().get("status"));
+ assertNotNull(response.getBody().get("dynamic"));
+ }
+
+ // 测试点赞动态接口
+ @Test
+ void testLikeDynamic() {
+ Map<String, Long> request = new HashMap<>();
+ request.put("userId", 1L);
+ request.put("dynamicId", 1L);
+
+ // 模拟 dynamicService.likeDynamic 返回
+ when(dynamicService.likeDynamic(1L, 1L)).thenReturn(true);
+
+ // 调用控制器方法
+ ResponseEntity<String> response = dynamicController.likeDynamic(request);
+
+ // 验证返回的结果
+ assertEquals(200, response.getStatusCodeValue());
+ assertEquals("Like successful", response.getBody());
+ }
+
+ // 测试取消点赞接口
+ @Test
+ void testUnlikeDynamic() {
+ Map<String, Long> request = new HashMap<>();
+ request.put("userId", 1L);
+ request.put("dynamicId", 1L);
+
+ // 模拟 dynamicService.unlikeDynamic 返回
+ when(dynamicService.unlikeDynamic(1L, 1L)).thenReturn(true);
+
+ // 调用控制器方法
+ ResponseEntity<String> response = dynamicController.unlikeDynamic(request);
+
+ // 验证返回的结果
+ assertEquals(200, response.getStatusCodeValue());
+ assertEquals("Unlike successful", response.getBody());
+ }
+}
diff --git a/src/test/java/com/example/myproject/controller/GroupControllerTest.java b/src/test/java/com/example/myproject/controller/GroupControllerTest.java
new file mode 100644
index 0000000..d8c8c2c
--- /dev/null
+++ b/src/test/java/com/example/myproject/controller/GroupControllerTest.java
@@ -0,0 +1,209 @@
+package com.example.myproject.controller;
+
+import com.example.myproject.controller.GroupController;
+import com.example.myproject.entity.Group;
+import com.example.myproject.entity.GroupComments;
+import com.example.myproject.service.GroupService;
+import com.example.myproject.utils.Result;
+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.ResponseEntity;
+
+import java.util.HashMap;
+import java.util.Map;
+
+import static org.mockito.Mockito.*;
+import static org.junit.jupiter.api.Assertions.*;
+
+
+class GroupControllerTest {
+
+ @InjectMocks
+ private GroupController groupController;
+
+ @Mock
+ private GroupService groupService;
+
+ @BeforeEach
+ void setup() {
+ MockitoAnnotations.openMocks(this);
+ }
+
+ // 测试创建小组
+
+ @Test
+ void createGroupTest() {
+ Group groupRequest = new Group();
+ groupRequest.setGroupName("Test Group");
+ groupRequest.setDescription("This is a test group");
+
+ // 模拟服务层的返回值
+ Map<String, Object> mockResponse = new HashMap<>();
+ mockResponse.put("group_id", 1L);
+ mockResponse.put("message", "兴趣小组创建成功");
+
+ ResponseEntity<Map<String, Object>> mockResponseEntity = ResponseEntity.ok(mockResponse);
+ when(groupService.createGroup(groupRequest)).thenReturn(mockResponseEntity);
+
+ // 调用控制器的方法
+ ResponseEntity<?> responseEntity = groupController.createGroup(groupRequest);
+ Map<String, Object> resultMap = (Map<String, Object>) responseEntity.getBody();
+ Result<Map<String, Object>> result = Result.success(resultMap, "兴趣小组创建成功");
+
+ // 验证返回的结果
+ assertEquals("200", result.getCode());
+ assertEquals("兴趣小组创建成功", result.getMsg());
+ assertEquals(1L, result.getData().get("group_id"));
+ }
+
+
+ // 测试加入小组接口
+ @Test
+ void testJoinGroup() {
+ Long groupId = 1L;
+ Long userId = 1L;
+
+ // 模拟服务层的返回值
+ Map<String, Object> mockResponse = new HashMap<>();
+ mockResponse.put("status", "success");
+ mockResponse.put("message", "成功加入小组");
+ when(groupService.joinGroup(groupId, userId)).thenReturn(ResponseEntity.ok(mockResponse));
+
+ // 调用控制器方法
+ Map<String, Long> requestBody = Map.of("user_id", userId);
+ ResponseEntity<Map<String, Object>> response = groupController.joinGroup(groupId, requestBody);
+
+ // 验证返回的结果
+ assertEquals(200, response.getStatusCodeValue());
+ assertEquals("success", response.getBody().get("status"));
+ assertEquals("成功加入小组", response.getBody().get("message"));
+ }
+
+ // 测试退出小组接口
+ @Test
+ void testLeaveGroup() {
+ Long groupId = 1L;
+ Long userId = 1L;
+
+ // 模拟服务层的返回值
+ Map<String, Object> mockResponse = new HashMap<>();
+ mockResponse.put("status", "success");
+ mockResponse.put("message", "成功退出小组");
+ when(groupService.leaveGroup(groupId, userId)).thenReturn(ResponseEntity.ok(mockResponse));
+
+ // 调用控制器方法
+ Map<String, Long> requestBody = Map.of("user_id", userId);
+ ResponseEntity<Map<String, Object>> response = groupController.leaveGroup(groupId, requestBody);
+
+ // 验证返回的结果
+ assertEquals(200, response.getStatusCodeValue());
+ assertEquals("success", response.getBody().get("status"));
+ assertEquals("成功退出小组", response.getBody().get("message"));
+ }
+
+ // 测试获取小组成员接口
+ @Test
+ void testGetGroupMembers() {
+ Long groupId = 1L;
+
+ // 模拟服务层的返回值
+ Map<String, Object> mockResponse = new HashMap<>();
+ mockResponse.put("status", "success");
+ mockResponse.put("members", "mock_members");
+ when(groupService.getGroupMembers(groupId)).thenReturn(ResponseEntity.ok(mockResponse));
+
+ // 调用控制器方法
+ ResponseEntity<Map<String, Object>> response = groupController.getGroupMembers(groupId);
+
+ // 验证返回的结果
+ assertEquals(200, response.getStatusCodeValue());
+ assertEquals("success", response.getBody().get("status"));
+ assertNotNull(response.getBody().get("members"));
+ }
+
+ // 测试发布帖子
+ @Test
+ void createPostTest() {
+ Long groupId = 1L;
+ Long userId = 2L;
+ String postContent = "Test post content";
+ String title = "Test post title";
+
+ // 模拟服务层的返回值
+ Map<String, Object> mockResponse = new HashMap<>();
+ mockResponse.put("post_id", 1L);
+ mockResponse.put("message", "帖子创建成功");
+
+ when(groupService.createPost(groupId, userId, postContent, title, null)).thenReturn(mockResponse);
+
+ // 调用控制器的方法
+ Map<String, Object> result = groupController.createPost(groupId, userId, postContent, title, null).getBody();
+
+ // 验证返回的结果
+ assertEquals("帖子创建成功", result.get("message"));
+ assertEquals(1L, result.get("post_id"));
+ }
+
+ // 测试点赞帖子
+ @Test
+ void likePostTest() {
+ Long postId = 1L;
+
+ // 模拟服务层的返回值
+ Map<String, Object> mockResponse = new HashMap<>();
+ mockResponse.put("status", "success");
+ mockResponse.put("message", "点赞成功");
+
+ when(groupService.likePost(postId)).thenReturn(mockResponse);
+
+ // 调用控制器的方法
+ Map<String, Object> resultMap = groupController.likePost(postId).getBody();
+
+ // 验证返回的结果
+ assertEquals("点赞成功", resultMap.get("message"));
+ }
+
+ // 测试取消点赞
+ @Test
+ void unlikePostTest() {
+ Long postId = 1L;
+
+ // 模拟服务层的返回值
+ Map<String, Object> mockResponse = new HashMap<>();
+ mockResponse.put("status", "success");
+ mockResponse.put("message", "取消点赞成功");
+
+ when(groupService.unlikePost(postId)).thenReturn(mockResponse);
+
+ // 调用控制器的方法
+ Map<String, Object> resultMap = groupController.unlikePost(postId).getBody();
+
+ // 验证返回的结果
+ assertEquals("取消点赞成功", resultMap.get("message"));
+ }
+
+ // 测试添加评论
+ @Test
+ void addCommentTest() {
+ Long postId = 1L;
+ GroupComments comment = new GroupComments();
+ comment.setUserId(2L);
+ comment.setContent("This is a comment");
+
+ // 模拟服务层的返回值
+ Map<String, Object> mockResponse = new HashMap<>();
+ mockResponse.put("status", "success");
+ mockResponse.put("message", "评论成功");
+
+ when(groupService.addComment(postId, comment)).thenReturn(mockResponse);
+
+ // 调用控制器的方法
+ Map<String, Object> resultMap = groupController.addComment(postId, comment).getBody();
+
+ // 验证返回的结果
+ assertEquals("评论成功", resultMap.get("message"));
+ }
+}
diff --git a/src/test/java/com/example/myproject/controller/LevelControllerTest.java b/src/test/java/com/example/myproject/controller/LevelControllerTest.java
new file mode 100644
index 0000000..c3d77b9
--- /dev/null
+++ b/src/test/java/com/example/myproject/controller/LevelControllerTest.java
@@ -0,0 +1,126 @@
+package com.example.myproject.controller;
+
+import com.example.myproject.controller.LevelController;
+import com.example.myproject.service.LevelService;
+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.ResponseEntity;
+
+import java.util.HashMap;
+import java.util.Map;
+
+import static org.mockito.Mockito.*;
+import static org.junit.jupiter.api.Assertions.*;
+
+class LevelControllerTest {
+
+ @InjectMocks
+ private LevelController levelController;
+
+ @Mock
+ private LevelService levelService;
+
+ @BeforeEach
+ void setup() {
+ MockitoAnnotations.openMocks(this);
+ }
+
+ // 测试获取用户经验接口
+ @Test
+ void testGetExperience() {
+ Long userId = 1L;
+ Map<String, Object> mockResponse = new HashMap<>();
+ mockResponse.put("current_experience", 1500);
+ mockResponse.put("level", "Intermediate");
+ mockResponse.put("next_level_experience", 2000);
+
+ // 模拟 levelService.getUserExperience 返回
+ when(levelService.getUserExperience(userId)).thenReturn(mockResponse);
+
+ // 调用控制器方法
+ Map<String, Object> response = levelController.getExperience(userId);
+
+ // 验证返回的结果
+ assertEquals(1500, response.get("current_experience"));
+ assertEquals("Intermediate", response.get("level"));
+ assertEquals(2000, response.get("next_level_experience"));
+ }
+
+ // 测试更新用户经验接口
+ @Test
+ void testUpdateExperience() {
+ Long userId = 1L;
+ Integer experience = 500;
+ String source = "Quest";
+ Map<String, Object> mockResponse = new HashMap<>();
+ mockResponse.put("status", "success");
+ mockResponse.put("message", "经验更新成功");
+ mockResponse.put("current_experience", 2000);
+
+ Map<String, Object> params = new HashMap<>();
+ params.put("user_id", userId);
+ params.put("experience", experience);
+ params.put("source", source);
+
+ // 模拟 levelService.updateExperience 返回
+ when(levelService.updateExperience(userId, experience, source)).thenReturn(mockResponse);
+
+ // 调用控制器方法
+ Map<String, Object> response = levelController.updateExperience(params);
+
+ // 验证返回的结果
+ assertEquals("success", response.get("status"));
+ assertEquals("经验更新成功", response.get("message"));
+ assertEquals(2000, response.get("current_experience"));
+ }
+
+ // 测试检查用户升级条件接口
+ @Test
+ void testCheckUpgrade() {
+ Long userId = 1L;
+ Map<String, Object> mockResponse = new HashMap<>();
+ mockResponse.put("can_upgrade", true);
+ mockResponse.put("next_level_experience", 2000);
+ mockResponse.put("current_experience", 1500);
+
+ // 模拟 levelService.checkUpgrade 返回
+ when(levelService.checkUpgrade(userId)).thenReturn(mockResponse);
+
+ // 调用控制器方法
+ Map<String, Object> response = levelController.checkUpgrade(userId);
+
+ // 验证返回的结果
+ assertTrue((Boolean) response.get("can_upgrade"));
+ assertEquals(2000, response.get("next_level_experience"));
+ assertEquals(1500, response.get("current_experience"));
+ }
+
+ // 测试升级用户等级接口
+ @Test
+ void testUpgradeUserLevel() {
+ Long userId = 1L;
+ Boolean canUpgrade = true;
+ Map<String, Object> mockResponse = new HashMap<>();
+ mockResponse.put("status", "success");
+ mockResponse.put("message", "升级成功");
+ mockResponse.put("new_level", "Advanced");
+
+ Map<String, Object> request = new HashMap<>();
+ request.put("user_id", userId);
+ request.put("can_upgrade", canUpgrade);
+
+ // 模拟 levelService.upgradeUserLevel 返回
+ when(levelService.upgradeUserLevel(userId, canUpgrade)).thenReturn(mockResponse);
+
+ // 调用控制器方法
+ Map<String, Object> response = levelController.upgradeUserLevel(request);
+
+ // 验证返回的结果
+ assertEquals("success", response.get("status"));
+ assertEquals("升级成功", response.get("message"));
+ assertEquals("Advanced", response.get("new_level"));
+ }
+}
diff --git a/src/test/java/com/example/myproject/controller/PostControllerTest.java b/src/test/java/com/example/myproject/controller/PostControllerTest.java
new file mode 100644
index 0000000..6586086
--- /dev/null
+++ b/src/test/java/com/example/myproject/controller/PostControllerTest.java
@@ -0,0 +1,279 @@
+package com.example.myproject.controller;
+
+import com.example.myproject.entity.Collections;
+import com.example.myproject.entity.Post;
+import com.example.myproject.entity.Users;
+import com.example.myproject.repository.CollectionsRepository;
+import com.example.myproject.repository.PostRepository;
+import com.example.myproject.repository.UserRepository;
+import com.example.myproject.service.PostService;
+import com.example.myproject.utils.Result;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.mockito.*;
+import org.springframework.web.multipart.MultipartFile;
+
+import java.util.*;
+
+import static org.mockito.Mockito.*;
+import static org.junit.jupiter.api.Assertions.*;
+
+class PostControllerTest {
+
+ @InjectMocks
+ private PostController postController;
+
+ @Mock
+ private PostService postService;
+
+ @Mock
+ private CollectionsRepository collectionsRepository;
+
+ @Mock
+ private PostRepository postRepository;
+
+ @Mock
+ private UserRepository userRepository;
+
+ @InjectMocks
+ private UserController userController;
+
+ @BeforeEach
+ void setup() {
+ MockitoAnnotations.openMocks(this);
+ }
+
+ // 测试创建帖子
+ void createPostTest() {
+ Long userId = 1L;
+ String postContent = "Test Post Content";
+ String title = "Test Post Title";
+ MultipartFile[] imageFiles = new MultipartFile[0]; // Empty array for simplicity
+
+ // 模拟服务层的返回值
+ Map<String, Object> responseMap = new HashMap<>();
+ responseMap.put("postNo", 123L);
+ responseMap.put("message", "帖子创建成功");
+
+ when(postService.createPost(userId, postContent, title, imageFiles)).thenReturn(responseMap);
+
+ // 调用控制器的方法
+ Map<String, Object> resultMap = postController.createPost(userId, postContent, title, imageFiles);
+
+ // 手动将 Map<String, Object> 包装到 Result.success()
+ Result<Map<String, Object>> result = Result.success(resultMap, "帖子创建成功");
+
+ // 验证返回的结果
+ assertEquals("200", result.getCode());
+ assertEquals("帖子创建成功", result.getMsg());
+ assertEquals(123L, result.getData().get("postNo"));
+ }
+
+ // 测试编辑帖子
+ @Test
+ void updatePostTest() {
+ Long postId = 1L;
+ Post post = new Post();
+ post.setPostNo(postId);
+ post.setTitle("Updated Title");
+ post.setPostContent("Updated Content");
+
+ // 模拟服务层的行为
+ doNothing().when(postService).updatePost(postId, post);
+
+ // 调用控制器的方法
+ String result = postController.updatePost(postId, post);
+
+ // 验证返回的结果
+ assertEquals("Post updated successfully!", result);
+ }
+
+ // 测试删除帖子
+ @Test
+ void deletePostTest() {
+ Long postId = 1L;
+
+ // 模拟服务层的行为
+ doNothing().when(postService).deletePost(postId);
+
+ // 调用控制器的方法
+ String result = postController.deletePost(postId);
+
+ // 验证返回的结果
+ assertEquals("Post deleted successfully!", result);
+ }
+
+ // 测试点赞帖子
+ @Test
+ void likePostTest() {
+ Long postId = 1L;
+ Long userId = 1L;
+
+ // 模拟服务层的行为
+ doNothing().when(postService).likePost(postId, userId);
+
+ // 创建请求体
+ Map<String, Long> requestBody = new HashMap<>();
+ requestBody.put("user_id", userId);
+
+ // 调用控制器的方法
+ String result = postController.likePost(postId, requestBody);
+
+ // 验证返回的结果
+ assertEquals("Post liked successfully!", result);
+ }
+
+ // 测试取消点赞帖子
+ @Test
+ void unlikePostTest() {
+ Long postId = 1L;
+ Long userId = 1L;
+
+ // 模拟服务层的行为
+ doNothing().when(postService).unlikePost(postId, userId);
+
+ // 创建请求体
+ Map<String, Long> requestBody = new HashMap<>();
+ requestBody.put("user_id", userId);
+
+ // 调用控制器的方法
+ String result = postController.unlikePost(postId, requestBody);
+
+ // 验证返回的结果
+ assertEquals("Post unliked successfully!", result);
+ }
+
+ // 测试收藏帖子
+ @Test
+ void collectPostTest() {
+ Long postId = 1L;
+ Long userId = 1L;
+
+ // 模拟服务层的行为
+ doNothing().when(postService).collectPost(postId, userId);
+
+ // 创建请求体
+ Map<String, Long> requestBody = new HashMap<>();
+ requestBody.put("user_id", userId);
+
+ // 调用控制器的方法
+ String result = postController.collectPost(postId, requestBody);
+
+ // 验证返回的结果
+ assertEquals("Post collected successfully!", result);
+ }
+
+ // 测试取消收藏帖子
+ @Test
+ void uncollectPostTest() {
+ Long postId = 1L;
+ Long userId = 1L;
+
+ // 模拟服务层的行为
+ doNothing().when(postService).uncollectPost(postId, userId);
+
+ // 创建请求体
+ Map<String, Long> requestBody = new HashMap<>();
+ requestBody.put("user_id", userId);
+
+ // 调用控制器的方法
+ String result = postController.uncollectPost(postId, requestBody);
+
+ // 验证返回的结果
+ assertEquals("Post uncollected successfully!", result);
+ }
+
+ // 测试获取所有帖子
+ @Test
+ void getAllPostsTest() {
+ // 模拟服务层的行为
+ Map<String, Object> responseMap = new HashMap<>();
+ responseMap.put("total", 5);
+ responseMap.put("posts", new ArrayList<>());
+
+ when(postService.getAllPosts()).thenReturn(responseMap);
+
+ // 调用控制器的方法
+ Map<String, Object> result = postController.getAllPosts();
+
+ // 验证返回的结果
+ assertEquals(5, result.get("total"));
+ }
+
+ // 测试根据帖子ID获取帖子
+ @Test
+ void getPostByIdTest() {
+ Long postId = 1L;
+ Map<String, Object> responseMap = new HashMap<>();
+ responseMap.put("postNo", 123L);
+ responseMap.put("message", "Post details");
+
+ // 模拟服务层的行为
+ when(postService.getPostById(postId)).thenReturn(responseMap);
+
+ // 调用控制器的方法
+ Map<String, Object> result = postController.getPostById(postId);
+
+ // 验证返回的结果
+ assertEquals("Post details", result.get("message"));
+ assertEquals(123L, result.get("postNo"));
+ }
+
+ // 测试获取用户收藏的所有帖子接口
+ @Test
+ void testGetAllCollections() {
+ Long userId = 1L;
+
+ // 模拟用户收藏的数据
+ Collections collection = new Collections();
+ collection.setCollectionId(1L);
+ collection.setUserId(userId);
+ collection.setPostNo(101L);
+
+ List<Collections> collections = new ArrayList<>();
+ collections.add(collection);
+
+ // 模拟帖子数据
+ Post post = new Post();
+ post.setPostNo(101L);
+ post.setTitle("Test Post Title");
+ post.setPostContent("Test Post Content");
+ post.setImageUrl("https://example.com/image.jpg");
+ post.setUser_id(2L); // 作者用户ID
+
+ Users user = new Users();
+ user.setUserId(2L);
+ user.setUsername("testUser");
+ user.setAvatarUrl("https://example.com/avatar.jpg");
+
+ // 设置模拟服务层的返回
+ when(postService.getAllCollections(userId)).thenReturn(Arrays.asList(
+ Map.of(
+ "postNo", post.getPostNo(),
+ "title", post.getTitle(),
+ "postContent", post.getPostContent(),
+ "imageUrl", post.getImageUrl(),
+ "userId", post.getUser_id(),
+ "username", user.getUsername(),
+ "avatarUrl", user.getAvatarUrl()
+ )
+ ));
+
+ // 调用控制器方法
+ List<Map<String, Object>> result = postController.getAllCollections(userId);
+
+ // 验证返回的结果
+ assertNotNull(result);
+ assertEquals(1, result.size()); // 验证返回数据的数量
+
+ // 验证返回的数据结构
+ Map<String, Object> postInfo = result.get(0);
+ assertEquals(101L, postInfo.get("postNo"));
+ assertEquals("Test Post Title", postInfo.get("title"));
+ assertEquals("Test Post Content", postInfo.get("postContent"));
+ assertEquals("https://example.com/image.jpg", postInfo.get("imageUrl"));
+ assertEquals(2L, postInfo.get("userId"));
+ assertEquals("testUser", postInfo.get("username"));
+ assertEquals("https://example.com/avatar.jpg", postInfo.get("avatarUrl"));
+ }
+}
diff --git a/src/test/java/com/example/myproject/controller/SeedCommentControllerTest.java b/src/test/java/com/example/myproject/controller/SeedCommentControllerTest.java
new file mode 100644
index 0000000..7fa6ff3
--- /dev/null
+++ b/src/test/java/com/example/myproject/controller/SeedCommentControllerTest.java
@@ -0,0 +1,91 @@
+package com.example.myproject.controller;
+
+import com.example.myproject.entity.SeedComment;
+import com.example.myproject.service.SeedCommentService;
+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.ResponseEntity;
+
+import java.util.HashMap;
+import java.util.Map;
+
+import static org.mockito.Mockito.*;
+import static org.junit.jupiter.api.Assertions.*;
+
+public class SeedCommentControllerTest {
+
+ @InjectMocks
+ private SeedCommentController seedCommentController;
+
+ @Mock
+ private SeedCommentService seedCommentService;
+
+ @BeforeEach
+ public void setUp() {
+ MockitoAnnotations.openMocks(this); // 初始化 Mockito 注解
+ }
+
+ // 测试发布评论
+ @Test
+ public void testPublishComment() {
+ int seedId = 1;
+ SeedComment seedComment = new SeedComment();
+ seedComment.setContent("Test comment content");
+ seedComment.setUserId(1);
+ seedComment.setComCommentId(0); // 顶级评论
+
+ // 模拟服务层的返回值
+ String expectedResponse = "{ \"status\": \"success\", \"message\": \"评论发布成功\" }";
+ when(seedCommentService.publishComment(seedId, seedComment)).thenReturn(expectedResponse);
+
+ // 调用控制器的方法
+ String result = seedCommentController.publishComment(seedId, seedComment);
+
+ // 验证结果
+ assertEquals(expectedResponse, result);
+ }
+
+ // 测试获取种子下所有评论
+ @Test
+ public void testGetAllComments() {
+ int seedId = 1;
+
+ // 模拟服务层的返回值
+ Map<String, Object> expectedResponse = new HashMap<>();
+ expectedResponse.put("status", "success");
+ expectedResponse.put("comments", "dummyComments"); // 示例返回数据
+
+ when(seedCommentService.getAllCommentsForSeed(seedId)).thenReturn(expectedResponse);
+
+ // 调用控制器的方法
+ Map<String, Object> result = seedCommentController.getAllComments(seedId);
+
+ // 验证结果
+ assertEquals(expectedResponse, result);
+ }
+
+ // 测试点赞切换操作
+ @Test
+ public void testToggleLike() {
+ Long commentId = 1L;
+ Map<String, Object> request = new HashMap<>();
+ request.put("user_id", 1L);
+
+ // 模拟服务层的返回值
+ Map<String, Object> expectedResponse = new HashMap<>();
+ expectedResponse.put("status", "success");
+ expectedResponse.put("message", "操作成功");
+ expectedResponse.put("liked", "true");
+
+ when(seedCommentService.toggleLike(commentId, 1L)).thenReturn(expectedResponse);
+
+ // 调用控制器的方法
+ Map<String, Object> result = seedCommentController.toggleLike(commentId, request);
+
+ // 验证结果
+ assertEquals(expectedResponse, result);
+ }
+}
diff --git a/src/test/java/com/example/myproject/controller/TaskControllerTest.java b/src/test/java/com/example/myproject/controller/TaskControllerTest.java
new file mode 100644
index 0000000..d0bb754
--- /dev/null
+++ b/src/test/java/com/example/myproject/controller/TaskControllerTest.java
@@ -0,0 +1,197 @@
+package com.example.myproject.controller;
+
+import com.example.myproject.controller.TaskController;
+import com.example.myproject.service.TaskService;
+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.ResponseEntity;
+
+import java.util.HashMap;
+import java.util.Map;
+
+import static org.mockito.Mockito.*;
+import static org.junit.jupiter.api.Assertions.*;
+
+class TaskControllerTest {
+
+ @InjectMocks
+ private TaskController taskController;
+
+ @Mock
+ private TaskService taskService;
+
+ @BeforeEach
+ void setup() {
+ MockitoAnnotations.openMocks(this);
+ }
+
+ // 测试获取当前用户的新手任务列表接口
+ @Test
+ void testGetAllTasks() {
+ Long userId = 1L;
+ Map<String, Object> mockResponse = new HashMap<>();
+ mockResponse.put("tasks", "mock_tasks");
+
+ // 模拟 taskService.getAllTasksForUser 返回
+ when(taskService.getAllTasksForUser(userId)).thenReturn(mockResponse);
+
+ // 调用控制器方法，改为通过请求参数传递 user_id
+ Map<String, Object> response = taskController.getAllTasks(userId);
+
+ // 验证返回的结果
+ assertEquals("mock_tasks", response.get("tasks"));
+ }
+
+ // 测试更新任务状态接口
+ @Test
+ void testUpdateTaskStatus() {
+ Long userId = 1L;
+ String taskId = "task_123";
+ Map<String, Object> mockResponse = new HashMap<>();
+ mockResponse.put("status", "success");
+ mockResponse.put("message", "任务状态已更新");
+
+ // 模拟 taskService.updateTaskStatus 返回
+ when(taskService.updateTaskStatus(userId, taskId)).thenReturn(mockResponse);
+
+ // 创建请求体
+ Map<String, Object> request = new HashMap<>();
+ request.put("user_id", userId);
+ request.put("task_id", taskId);
+
+ // 调用控制器方法
+ Map<String, Object> response = taskController.updateTaskStatus(request);
+
+ // 验证返回的结果
+ assertEquals("success", response.get("status"));
+ assertEquals("任务状态已更新", response.get("message"));
+ }
+
+ // 测试获取当前经验和任务奖励接口
+ @Test
+ void testGetExperience() {
+ Long userId = 1L;
+ Map<String, Object> mockResponse = new HashMap<>();
+ mockResponse.put("current_experience", 1500);
+ mockResponse.put("level", "Intermediate");
+ mockResponse.put("reward", Map.of("experience", 1000, "points", 200));
+
+ // 模拟 taskService.getUserExperience 返回
+ when(taskService.getUserExperience(userId)).thenReturn(mockResponse);
+
+ // 创建请求体
+ Map<String, Object> request = new HashMap<>();
+ request.put("user_id", userId);
+
+ // 调用控制器方法
+ Map<String, Object> response = taskController.getExperience(request);
+
+ // 验证返回的结果
+ assertEquals(1500, response.get("current_experience"));
+ assertEquals("Intermediate", response.get("level"));
+ assertTrue(response.containsKey("reward"));
+ }
+
+ // 测试获取当前的指引步骤接口
+ @Test
+ void testGetNewStep() {
+ Long userId = 1L;
+ Map<String, Object> mockResponse = new HashMap<>();
+ mockResponse.put("current_step", "step_1");
+ mockResponse.put("total_steps", 5);
+ mockResponse.put("step_description", "Complete the introduction task");
+
+ // 模拟 taskService.getNewStep 返回
+ when(taskService.getNewStep(userId)).thenReturn(mockResponse);
+
+ // 调用控制器方法，改为通过请求参数传递 user_id
+ Map<String, Object> response = taskController.getNewStep(userId);
+
+ // 验证返回的结果
+ assertEquals("step_1", response.get("current_step"));
+ assertEquals(5, response.get("total_steps"));
+ assertEquals("Complete the introduction task", response.get("step_description"));
+ }
+
+ // 测试更新进度接口
+ @Test
+ void testUpdateProgress() {
+ Long userId = 1L;
+ String taskId = "task_123";
+ Integer progress = 50;
+ Map<String, Object> mockResponse = new HashMap<>();
+ mockResponse.put("status", "success");
+ mockResponse.put("message", "进度已更新");
+
+ // 模拟 taskService.updateTaskProgress 返回
+ when(taskService.updateTaskProgress(userId, taskId, progress)).thenReturn(mockResponse);
+
+ // 创建请求体
+ Map<String, Object> request = new HashMap<>();
+ request.put("user_id", userId);
+ request.put("task_id", taskId);
+ request.put("progress", progress);
+
+ // 调用控制器方法
+ Map<String, Object> response = taskController.updateProgress(request);
+
+ // 验证返回的结果
+ assertEquals("success", response.get("status"));
+ assertEquals("进度已更新", response.get("message"));
+ }
+
+ // 测试领取任务奖励接口
+ @Test
+ void testRewardClaim() {
+ Long userId = 1L;
+ String taskId = "task_123";
+ Map<String, Object> mockResponse = new HashMap<>();
+ mockResponse.put("status", "success");
+ mockResponse.put("message", "奖励已领取");
+ mockResponse.put("reward", Map.of("experience", 1000, "points", 200));
+
+ // 模拟 taskService.claimReward 返回
+ when(taskService.claimReward(userId, taskId)).thenReturn(mockResponse);
+
+ // 创建请求体
+ Map<String, Object> request = new HashMap<>();
+ request.put("user_id", userId);
+ request.put("task_id", taskId);
+
+ // 调用控制器方法
+ Map<String, Object> response = taskController.rewardClaim(request);
+
+ // 验证返回的结果
+ assertEquals("success", response.get("status"));
+ assertEquals("奖励已领取", response.get("message"));
+ assertTrue(response.containsKey("reward"));
+ }
+
+ // 测试检查任务奖励状态接口
+ @Test
+ void testRewardReview() {
+ Long userId = 1L;
+ String taskId = "task_123";
+ Map<String, Object> mockResponse = new HashMap<>();
+ mockResponse.put("status", "reward_not_issued");
+ mockResponse.put("message", "任务奖励未被领取");
+
+ // 模拟 taskService.checkRewardStatus 返回
+ when(taskService.checkRewardStatus(userId, taskId)).thenReturn(mockResponse);
+
+ // 创建请求体
+ Map<String, Object> request = new HashMap<>();
+ request.put("user_id", userId);
+ request.put("task_id", taskId);
+
+ // 调用控制器方法
+ Map<String, Object> response = taskController.rewardReview(request);
+
+ // 验证返回的结果
+ assertEquals("reward_not_issued", response.get("status"));
+ assertEquals("任务奖励未被领取", response.get("message"));
+ }
+}
diff --git a/src/test/java/com/example/myproject/controller/TorrentControllerTest.java b/src/test/java/com/example/myproject/controller/TorrentControllerTest.java
deleted file mode 100644
index e69de29..0000000
--- a/src/test/java/com/example/myproject/controller/TorrentControllerTest.java
+++ /dev/null
diff --git a/src/test/java/com/example/myproject/controller/UserControllerTest.java b/src/test/java/com/example/myproject/controller/UserControllerTest.java
index d332f31..a97e169 100644
--- a/src/test/java/com/example/myproject/controller/UserControllerTest.java
+++ b/src/test/java/com/example/myproject/controller/UserControllerTest.java
@@ -1,162 +1,234 @@
package com.example.myproject.controller;
-import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
-import com.example.myproject.entity.User;
-import com.example.myproject.service.EmailService;
+import com.example.myproject.entity.Users;
import com.example.myproject.service.UserService;
-import com.example.myproject.mapper.UserMapper;
-import com.example.myproject.mapper.VerificationTokenMapper;
-import com.example.myproject.common.base.Result;
+import com.example.myproject.repository.UserRepository;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
-import org.mockito.*;
-import org.springframework.http.ResponseEntity;
-import org.springframework.security.authentication.AuthenticationManager;
-import org.springframework.security.core.Authentication;
-import org.springframework.security.core.AuthenticationException;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.MockitoAnnotations;
-import static org.junit.jupiter.api.Assertions.*;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Optional;
+
import static org.mockito.Mockito.*;
+import static org.junit.jupiter.api.Assertions.*;
class UserControllerTest {
+ @Mock
+ private UserService userService;
+
+ @Mock
+ private UserRepository userRepository;
+
@InjectMocks
private UserController userController;
- @Mock
- private UserService userService;
- @Mock
- private UserMapper userMapper;
- @Mock
- private EmailService emailService;
- @Mock
- private AuthenticationManager authenticationManager;
- @Mock
- private VerificationTokenMapper verificationTokenMapper;
-
@BeforeEach
- void setup() {
+ void setUp() {
+ // 初始化模拟对象
MockitoAnnotations.openMocks(this);
}
+ // 测试生成邀请码接口
@Test
- void loginController_success() {
- String username = "testuser";
- String password = "testpass";
- User mockUser = new User();
- mockUser.setUsername(username);
+ void testGenerateInviteCode() {
+ // 设置输入数据
+ Map<String, Object> request = new HashMap<>();
+ request.put("user_id", 1L);
- Authentication mockAuth = mock(Authentication.class);
- when(authenticationManager.authenticate(any())).thenReturn(mockAuth);
- when(userMapper.selectOne(any(QueryWrapper.class))).thenReturn(mockUser);
+ // 模拟服务层的返回
+ Map<String, Object> responseMap = new HashMap<>();
+ responseMap.put("status", "success");
+ responseMap.put("message", "邀请码生成成功");
+ responseMap.put("invite_code", "ABC123XYZ");
- Result result = userController.loginController(username, password);
+ when(userService.generateInviteCode(1L)).thenReturn(responseMap);
- assertEquals("200", result.getCode());
- assertEquals(mockUser, result.getData());
+ // 调用控制器方法
+ Map<String, Object> resultMap = userController.generateInviteCode(request);
+
+ // 验证返回结果
+ assertEquals("success", resultMap.get("status"));
+ assertEquals("邀请码生成成功", resultMap.get("message"));
+ assertEquals("ABC123XYZ", resultMap.get("invite_code"));
+
+ // 验证服务层方法是否被调用
+ verify(userService, times(1)).generateInviteCode(1L);
}
-
+ // 测试用户修改密码接口
@Test
- void loginController_failure() {
- String username = "user";
- String password = "wrongpass";
+ void testChangePassword() {
+ Long userId = 1L;
+ Map<String, Object> request = new HashMap<>();
+ request.put("user_id", userId);
+ request.put("old_password", "oldPassword");
+ request.put("new_password", "newPassword");
+ request.put("confirm_password", "newPassword");
- // 模拟认证失败，抛出 Bad credentials 异常
- when(authenticationManager.authenticate(any()))
- .thenThrow(new AuthenticationException("Bad credentials") {});
+ // 模拟服务层的返回
+ String resultMessage = "密码修改成功";
+ when(userService.changePassword(userId, "oldPassword", "newPassword", "newPassword"))
+ .thenReturn(resultMessage);
+ // 调用控制器方法
+ Map<String, Object> resultMap = userController.changePassword(request);
- // 调用登录接口
- Result result = userController.loginController(username, password);
+ // 验证返回结果
+ assertEquals("密码修改成功", resultMap.get("message"));
+ assertEquals("success", resultMap.get("status"));
- // 断言返回的状态码和消息
- assertEquals("401", result.getCode());
- assertTrue(result.getMsg().contains("登录失败"));
+ // 验证服务层方法是否被调用
+ verify(userService, times(1)).changePassword(userId, "oldPassword", "newPassword", "newPassword");
+ }
+
+ // 测试用户注册接口
+ @Test
+ void testRegister() {
+ // 设置输入数据
+ Map<String, Object> request = new HashMap<>();
+ request.put("username", "testUser");
+ request.put("email", "test@example.com");
+ request.put("password", "password");
+ request.put("role", "USER");
+ request.put("inviteCode", "12345");
+
+ // 模拟服务层的返回
+ String resultMessage = "用户注册成功";
+ when(userService.registerUser("testUser", "test@example.com", "password", "USER", "12345"))
+ .thenReturn(resultMessage);
+
+ // 调用控制器方法
+ Map<String, Object> resultMap = userController.register(request);
+
+ // 验证返回结果
+ assertEquals("用户注册成功", resultMap.get("msg"));
+
+ // 验证服务层方法是否被调用
+ verify(userService, times(1)).registerUser("testUser", "test@example.com", "password", "USER", "12345");
}
@Test
- void registerController_emailExists() {
- User user = new User();
+ void testLogin() {
+ String username = "testUser";
+ String password = "password";
+
+ // 模拟服务层的返回
+ String loginMessage = "登录成功";
+ when(userService.loginUser("testUser", "password")).thenReturn(loginMessage);
+
+ // 模拟用户查询
+ Users user = new Users();
+ user.setUserId(1L);
+ user.setUsername("testUser");
user.setEmail("test@example.com");
+ when(userRepository.findByUsername("testUser")).thenReturn(Optional.of(user));
- when(userService.checkEmailExists(user.getEmail())).thenReturn(true);
+ // 设置请求数据
+ Map<String, Object> request = new HashMap<>();
+ request.put("username", username);
+ request.put("password", password);
- Result result = userController.registerController(user);
+ // 调用控制器方法
+ Map<String, Object> resultMap = userController.login(request);
- assertEquals("邮箱冲突", result.getCode());
+ // 验证返回结果
+ assertEquals("登录成功", resultMap.get("msg"));
+
+ // 验证 user 不是 Map 类型，而是 Users 对象
+ Users loggedInUser = (Users) resultMap.get("user");
+ assertNotNull(loggedInUser);
+ assertEquals("testUser", loggedInUser.getUsername());
+ assertEquals("test@example.com", loggedInUser.getEmail());
+
+ // 验证服务层方法是否被调用
+ verify(userService, times(1)).loginUser("testUser", "password");
}
+
+ // 测试获取用户个人资料接口
@Test
- void registerController_success() {
- User user = new User();
+ void testGetProfile() {
+ Long userId = 1L;
+
+ // Mock 用户数据
+ Users user = new Users();
+ user.setUserId(userId);
+ user.setUsername("testUser");
user.setEmail("test@example.com");
+ user.setAvatarUrl("https://example.com/avatar.jpg");
- when(userService.checkEmailExists(user.getEmail())).thenReturn(false);
- when(userService.preRegisterUser(user)).thenReturn(true);
+ // 模拟服务层返回
+ Map<String, Object> profileData = new HashMap<>();
+ profileData.put("avatarUrl", user.getAvatarUrl());
+ profileData.put("username", user.getUsername());
+ profileData.put("email", user.getEmail());
+ when(userService.getProfile(userId)).thenReturn(profileData);
- Result result = userController.registerController(user);
+ // 调用控制器方法
+ Map<String, Object> resultMap = userController.getProfile(userId);
- assertEquals("200", result.getCode());
- assertEquals(user.getEmail(), ((User) result.getData()).getEmail());
+ // 验证返回结果
+ assertEquals("testUser", resultMap.get("username"));
+ assertEquals("test@example.com", resultMap.get("email"));
+ assertEquals("https://example.com/avatar.jpg", resultMap.get("avatarUrl"));
+
+ // 验证服务层方法是否被调用
+ verify(userService, times(1)).getProfile(userId);
+ }
+
+ // 测试修改用户个人资料接口
+ @Test
+ void testEditProfile() {
+ Long userId = 1L;
+ Map<String, Object> profileData = new HashMap<>();
+ profileData.put("avatarUrl", "https://example.com/avatar.jpg");
+ profileData.put("nickname", "newNickname");
+ profileData.put("gender", "Male");
+ profileData.put("description", "Updated description");
+ profileData.put("hobbies", "Reading, Hiking");
+
+ // 模拟服务层的返回
+ when(userService.editProfile(userId, "https://example.com/avatar.jpg", "newNickname", "Male", "Updated description", "Reading, Hiking"))
+ .thenReturn(true);
+
+ // 调用控制器方法
+ Map<String, String> resultMap = userController.editProfile(userId, profileData);
+
+ // 验证返回结果
+ assertEquals("用户资料更新成功", resultMap.get("message"));
+
+ // 验证服务层方法是否被调用
+ verify(userService, times(1)).editProfile(userId, "https://example.com/avatar.jpg", "newNickname", "Male", "Updated description", "Reading, Hiking");
}
@Test
- void verifyEmailCode_success() {
- when(userService.verifyEmail("test@example.com", "123456")).thenReturn(true);
+ public void testCalculateShareRate() {
+ Long userId = 1L;
- UserController.VerificationRequest request = new UserController.VerificationRequest();
- request.setEmail("test@example.com");
- request.setCode("123456");
+ // 模拟 UserService 返回的结果
+ Map<String, Object> expectedResponse = Map.of(
+ "status", "success",
+ "message", "分享率计算成功",
+ "shareRate", 0.5f
+ );
- Result result = userController.verifyEmailCode(request);
+ // 设置用户数据
+ Users user = new Users();
+ user.setUserId(userId);
+ user.setUploadCount(50f); // 上传量为50
+ user.setDownloadCount(100f); // 下载量为100
+ when(userService.calculateShareRate(userId)).thenReturn(expectedResponse);
- assertEquals("200", result.getCode());
- }
+ // 调用接口
+ Map<String, Object> result = userController.calculateShareRate(userId);
- @Test
- void verifyEmailCode_failure() {
- when(userService.verifyEmail("test@example.com", "000000")).thenReturn(false);
-
- UserController.VerificationRequest request = new UserController.VerificationRequest();
- request.setEmail("test@example.com");
- request.setCode("000000");
-
- Result result = userController.verifyEmailCode(request);
-
- assertEquals("验证失败", result.getCode());
- }
-
- @Test
- void checkPassword_success() {
- when(userService.checkPassword(1L, "abc123")).thenReturn(true);
-
- Result<String> result = userController.checkPassword(1L, "abc123");
-
- assertEquals("200", result.getCode());
- assertEquals("原始密码输入正确", result.getMsg());
- }
-
- @Test
- void checkPassword_failure() {
- when(userService.checkPassword(1L, "wrong")).thenReturn(false);
-
- Result<String> result = userController.checkPassword(1L, "wrong");
-
- assertEquals("305", result.getCode());
- assertEquals("原始密码输入错误", result.getMsg());
- }
-
- @Test
- void sendVerificationEmail_userNotFound() {
- UserController.EmailRequest request = new UserController.EmailRequest();
- request.setEmail("notfound@example.com");
-
- when(userMapper.selectOne(any())).thenReturn(null);
-
- ResponseEntity<Result> response = userController.sendVerificationEmail(request);
-
- assertEquals(400, response.getStatusCodeValue());
- assertEquals("1", response.getBody().getCode());
+ // 验证结果
+ assertEquals(expectedResponse, result);
+ verify(userService, times(1)).calculateShareRate(userId); // 验证服务方法是否被调用
}
}
diff --git a/src/test/java/com/example/myproject/controller/UserFollowControllerTest.java b/src/test/java/com/example/myproject/controller/UserFollowControllerTest.java
new file mode 100644
index 0000000..29bf47f
--- /dev/null
+++ b/src/test/java/com/example/myproject/controller/UserFollowControllerTest.java
@@ -0,0 +1,132 @@
+package com.example.myproject.controller;
+
+import com.example.myproject.controller.UserFollowController;
+import com.example.myproject.service.UserFollowService;
+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.ResponseEntity;
+import java.util.List;
+
+import java.util.Map;
+
+import static org.mockito.Mockito.*;
+import static org.junit.jupiter.api.Assertions.*;
+
+class UserFollowControllerTest {
+
+ @InjectMocks
+ private UserFollowController userFollowController;
+
+ @Mock
+ private UserFollowService userFollowService;
+
+ @BeforeEach
+ void setup() {
+ MockitoAnnotations.openMocks(this);
+ }
+
+ // 测试用户关注接口
+ @Test
+ void testFollow() {
+ Long followerId = 1L;
+ Long followedId = 2L;
+ Map<String, Object> mockResponse = Map.of(
+ "status", "success",
+ "message", "关注成功"
+ );
+
+ // 模拟 userFollowService.follow() 返回
+ when(userFollowService.follow(followerId, followedId)).thenReturn(mockResponse);
+
+ // 创建请求体
+ Map<String, Long> request = Map.of("follower_id", followerId);
+
+ // 调用控制器方法
+ ResponseEntity<Map<String, Object>> responseEntity = userFollowController.follow(followedId, request);
+
+ // 验证返回的状态码和内容
+ assertEquals(200, responseEntity.getStatusCodeValue());
+ assertEquals("success", responseEntity.getBody().get("status"));
+ assertEquals("关注成功", responseEntity.getBody().get("message"));
+ }
+
+ // 测试取消关注接口
+ @Test
+ void testUnfollow() {
+ Long followerId = 1L;
+ Long followedId = 2L;
+ Map<String, Object> mockResponse = Map.of(
+ "status", "success",
+ "message", "取消关注成功"
+ );
+
+ // 模拟 userFollowService.unfollow() 返回
+ when(userFollowService.unfollow(followerId, followedId)).thenReturn(mockResponse);
+
+ // 创建请求体
+ Map<String, Long> request = Map.of("follower_id", followerId);
+
+ // 调用控制器方法
+ ResponseEntity<Map<String, Object>> responseEntity = userFollowController.unfollow(followedId, request);
+
+ // 验证返回的状态码和内容
+ assertEquals(200, responseEntity.getStatusCodeValue());
+ assertEquals("success", responseEntity.getBody().get("status"));
+ assertEquals("取消关注成功", responseEntity.getBody().get("message"));
+ }
+
+ // 测试获取某个用户的粉丝列表接口
+ @Test
+ void testGetFollowers() {
+ Long userId = 1L;
+ Map<String, Object> mockResponse = Map.of(
+ "status", "success",
+ "total", 2,
+ "followers", List.of(
+ Map.of("user_id", 2L, "username", "user2", "avatar_url", "url2"),
+ Map.of("user_id", 3L, "username", "user3", "avatar_url", "url3")
+ )
+ );
+
+ // 模拟 userFollowService.getFollowers() 返回
+ when(userFollowService.getFollowers(userId)).thenReturn(mockResponse);
+
+ // 调用控制器方法
+ ResponseEntity<Map<String, Object>> responseEntity = userFollowController.getFollowers(userId);
+
+ // 验证返回的状态码和内容
+ assertEquals(200, responseEntity.getStatusCodeValue());
+ assertEquals("success", responseEntity.getBody().get("status"));
+ assertEquals(2, responseEntity.getBody().get("total"));
+ assertEquals(2, ((List<?>) responseEntity.getBody().get("followers")).size());
+ }
+
+ // 测试获取某个用户的关注列表接口
+ @Test
+ void testGetFollowing() {
+ Long userId = 1L;
+ Map<String, Object> mockResponse = Map.of(
+ "status", "success",
+ "total", 2,
+ "following", List.of(
+ Map.of("user_id", 2L, "username", "user2", "avatar_url", "url2"),
+ Map.of("user_id", 3L, "username", "user3", "avatar_url", "url3")
+ )
+ );
+
+ // 模拟 userFollowService.getFollowing() 返回
+ when(userFollowService.getFollowing(userId)).thenReturn(mockResponse);
+
+ // 调用控制器方法
+ ResponseEntity<Map<String, Object>> responseEntity = userFollowController.getFollowing(userId);
+
+ // 验证返回的状态码和内容
+ assertEquals(200, responseEntity.getStatusCodeValue());
+ assertEquals("success", responseEntity.getBody().get("status"));
+ assertEquals(2, responseEntity.getBody().get("total"));
+ assertEquals(2, ((List<?>) responseEntity.getBody().get("following")).size());
+ }
+}
diff --git a/src/test/java/com/example/myproject/controller/UserMessageControllerTest.java b/src/test/java/com/example/myproject/controller/UserMessageControllerTest.java
new file mode 100644
index 0000000..4fcbcc7
--- /dev/null
+++ b/src/test/java/com/example/myproject/controller/UserMessageControllerTest.java
@@ -0,0 +1,95 @@
+package com.example.myproject.controller;
+
+import com.example.myproject.service.UserMessageService;
+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.ResponseEntity;
+
+import java.util.HashMap;
+import java.util.Map;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.mockito.Mockito.when;
+
+class UserMessageControllerTest {
+
+ @InjectMocks
+ private UserMessageController userMessageController;
+
+ @Mock
+ private UserMessageService userMessageService;
+
+ @BeforeEach
+ void setup() {
+ MockitoAnnotations.openMocks(this);
+ }
+
+ @Test
+ void testSendMessage() {
+ // 准备测试数据
+ Map<String, Object> params = new HashMap<>();
+ params.put("sender_id", 1L);
+ params.put("receiver_id", 2L);
+ params.put("content", "测试消息");
+
+ Map<String, Object> mockResponse = new HashMap<>();
+ mockResponse.put("status", "success");
+ mockResponse.put("message", "私信发送成功");
+ mockResponse.put("message_id", 100L);
+
+ // 模拟Service方法调用
+ when(userMessageService.sendMessage(1L, 2L, "测试消息")).thenReturn(mockResponse);
+
+ // 执行测试
+ ResponseEntity<Map<String, Object>> response = userMessageController.sendMessage(params);
+
+ // 验证结果
+ assertEquals(200, response.getStatusCodeValue());
+ assertEquals("success", response.getBody().get("status"));
+ assertEquals("私信发送成功", response.getBody().get("message"));
+ assertEquals(100L, response.getBody().get("message_id"));
+ }
+
+ @Test
+ void testGetUserMessages() {
+ // 准备测试数据
+ Long userId = 1L;
+
+ Map<String, Object> mockResponse = new HashMap<>();
+ mockResponse.put("status", "success");
+ mockResponse.put("messages", new HashMap<>());
+
+ // 模拟Service方法调用
+ when(userMessageService.getUserMessages(userId)).thenReturn(mockResponse);
+
+ // 执行测试
+ ResponseEntity<Map<String, Object>> response = userMessageController.getUserMessages(userId);
+
+ // 验证结果
+ assertEquals(200, response.getStatusCodeValue());
+ assertEquals("success", response.getBody().get("status"));
+ }
+
+ @Test
+ void testGetMessage() {
+ // 准备测试数据
+ Long messageId = 1L;
+
+ Map<String, Object> mockResponse = new HashMap<>();
+ mockResponse.put("status", "success");
+ mockResponse.put("message", new HashMap<>());
+
+ // 模拟Service方法调用
+ when(userMessageService.getMessage(messageId)).thenReturn(mockResponse);
+
+ // 执行测试
+ ResponseEntity<Map<String, Object>> response = userMessageController.getMessage(messageId);
+
+ // 验证结果
+ assertEquals(200, response.getStatusCodeValue());
+ assertEquals("success", response.getBody().get("status"));
+ }
+}
\ No newline at end of file