package com.example.demosystem.service.impl;

import com.example.demosystem.entity.User;
import com.example.demosystem.mapper.UserMapper;
import com.example.demosystem.vo.UserVO;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;

import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.Mockito.when;

// 【关键】@ExtendWith(MockitoExtension.class): 告诉 JUnit 5 使用 Mockito 扩展。
// 它会负责初始化被 @Mock 和 @InjectMocks 注解的字段。
@ExtendWith(MockitoExtension.class)
@DisplayName("用户服务纯单元测试")
class UserServiceImplTest {

    // @InjectMocks: 告诉 Mockito 创建 UserServiceImpl 的一个真实实例。
    // 然后，Mockito 会查找所有被 @Mock 标注的字段，并自动将它们注入到这个实例中。
    // 这就是我们的“发动机”。
    @InjectMocks
    private UserServiceImpl userService;

    // @Mock: 告诉 Mockito 创建一个 UserMapper 接口的模拟实现（一个“假的”对象）。
    // 所有对这个 userMapper 实例的方法调用都会被 Mockito 拦截，而不会执行任何真实代码。
    // 这就是我们的“假变速箱”。
    @Mock
    private UserMapper userMapper;

    @Test
    @DisplayName("当用户存在时，根据ID应能成功查询到用户信息")
    void testFindUserById_whenUserExists() {
        // --- GIVEN (给定一个预设条件) ---
        // 1. 我们虚构一个 User 实体对象，作为 userMapper 的预期返回值。
        User mockUser = new User();
        mockUser.setId(1L);
        mockUser.setUsername("testuser");
        mockUser.setNickname("测试用户");
        mockUser.setStatus(1);

        // 2. 定义模拟对象的行为（“打桩”）：
        // 当调用 userMapper.selectById(1L) 方法时，我们并不执行真实的 SQL，
        // 而是让 Mockito 直接返回上面创建的 mockUser 对象。
        when(userMapper.selectById(1L)).thenReturn(mockUser);

        // --- WHEN (执行我们要测试的动作) ---
        // 调用我们真正要测试的 service 方法。
        UserVO resultVO = userService.findUserById(1L);

        // --- THEN (验证结果是否符合预期) ---
        // 使用 AssertJ 进行流式断言，验证 service 的转换逻辑是否正确。
        assertThat(resultVO).isNotNull();
        assertThat(resultVO.getId()).isEqualTo(1L);
        assertThat(resultVO.getUserName()).isEqualTo("testuser");
        assertThat(resultVO.getNickname()).isEqualTo("测试用户");
    }

    @Test
    @DisplayName("当用户不存在时，根据ID查询应返回null")
    void testFindUserById_whenUserNotExists() {
        // --- GIVEN ---
        // 定义行为：当调用 userMapper.selectById 一个不存在的ID (如99L) 时，返回 null。
        when(userMapper.selectById(99L)).thenReturn(null);

        // --- WHEN ---
        UserVO resultVO = userService.findUserById(99L);

        // --- THEN ---
        // 验证当 mapper 返回 null 时，service 是否也正确地返回了 null。
        assertThat(resultVO).isNull();
    }
}

// UserService.java
void deleteUserById(Long id);

// UserServiceImpl.java
@Override
public void deleteUserById(Long id) {
    // 核心逻辑就是调用 mapper
    userMapper.deleteById(id); 
}

// ... (imports and existing class structure) ...
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;

// ... (within UserServiceImplTest class) ...

    @Test
    @DisplayName("删除用户时，应正确调用Mapper的deleteById方法")
    void testDeleteUser_shouldCallMapperCorrectly() {
        // --- GIVEN ---
        // 对于 void 方法，通常我们不需要"打桩"，因为没有返回值需要我们去模拟。
        // 当然，如果 `userMapper.deleteById` 会抛出异常，我们也可以用 when(...).thenThrow(...) 来打桩，
        // 这将在 6.2.5 节讲解。
        // 注意,如果这里测试失败的话是我们之前的service使用Hutool进行了判断，他和mock并不是很兼容需要删除掉判断检测是否已存在
        Long userIdToDelete = 1L;

        // --- WHEN ---
        // 执行我们要测试的 void 方法
        userService.deleteUserById(userIdToDelete);

        // --- THEN ---
        // 【关键】使用 Mockito.verify() 来验证行为
        // 这行代码的意思是：“请验证 userMapper 这个模拟对象，
        // 它的 deleteById 方法是否被调用了，并且调用次数是否恰好为 1 次，
        // 且传入的参数是否就是 userIdToDelete (1L)？”
        // 如果上述任一条件不满足（例如，没被调用、被调用了2次、或参数是2L），测试将失败。
        verify(userMapper, times(1)).deleteById(userIdToDelete);
    }

@Override
public Long saveUser(UserEditDTO dto) {
    // 1. 业务校验：断言用户名不存在
    User existingUser = userMapper.selectOne(
            new QueryWrapper<User>().lambda().eq(User::getUsername, dto.getUsername()));
    if (existingUser != null) {
        // 如果用户已存在，抛出自定义业务异常
        throw new BusinessException(ResultCode.UserAlreadyExists);
    }

    // 2. DTO -> PO: 使用Convert一步到位
    User user = Convert.convert(User.class, dto);

    // 3. 与另一个服务交互
    notificationService.sendWelcomeEmailAsync(dto.getUsername());

    // 4. 设置内部默认值
    user.setStatus(1);
    user.setCreateTime(LocalDateTime.now());

    // 5. 核心持久化操作
    userMapper.insert(user);
    
    return user.getId();
}

package com.example.demosystem.service.impl;

import com.example.demosystem.dto.user.UserEditDTO;
import com.example.demosystem.entity.User;
import com.example.demosystem.mapper.UserMapper;
import com.example.demosystem.service.NotificationService;
import com.example.demosystem.vo.UserVO;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.ArgumentCaptor;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;

import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.Mockito.*;

// 【关键】@ExtendWith(MockitoExtension.class): 告诉 JUnit 5 使用 Mockito 扩展。
// 它会负责初始化被 @Mock 和 @InjectMocks 注解的字段。
@ExtendWith(MockitoExtension.class)
@DisplayName("用户服务纯单元测试")
class UserServiceImplTest {

    // @InjectMocks: 告诉 Mockito 创建 UserServiceImpl 的一个真实实例。
    // 然后，Mockito 会查找所有被 @Mock 标注的字段，并自动将它们注入到这个实例中。
    // 这就是我们的“发动机”。
    @InjectMocks
    private UserServiceImpl userService;

    // @Mock: 告诉 Mockito 创建一个 UserMapper 接口的模拟实现（一个“假的”对象）。
    // 所有对这个 userMapper 实例的方法调用都会被 Mockito 拦截，而不会执行任何真实代码。
    // 这就是我们的“假变速箱”。
    @Mock
    private UserMapper userMapper;

    @Mock
    private NotificationService notificationService;

    @Test
    @DisplayName("保存用户成功路径：应设置默认值、调用邮件服务和插入方法")
    void testSaveUser_happyPath() {
        // --- GIVEN ---
        // 1. 准备输入数据
        UserEditDTO newUserDTO = new UserEditDTO();
        newUserDTO.setUsername("newUser");
        newUserDTO.setEmail("newUser@example.com");

        // 2. 设定前置校验的行为：模拟用户不存在
        // any() 是一个参数匹配器，表示我们不关心具体的查询条件是什么
        when(userMapper.selectOne(any())).thenReturn(null);


        // 3. 准备参数捕获器，用于捕获传递给 insert 方法的 User 对象
        ArgumentCaptor<User> userArgumentCaptor = ArgumentCaptor.forClass(User.class);

        // --- WHEN ---
        userService.saveUser(newUserDTO);


        // --- THEN ---
        // 1. 验证与 NotificationService 的交互
        // 验证 notificationService.sendWelcomeEmailAsync 方法被调用了1次，
        // 且传入的参数是 "newUser"
        verify(notificationService, times(1)).sendWelcomeEmailAsync("newUser");

        // 2. 验证与 UserMapper 的交互，并捕获参数
        // 验证 userMapper.insert 方法被调用了1次，并捕获传入的 User 对象
        verify(userMapper, times(1)).insert(userArgumentCaptor.capture());

        // 3. 对捕获的参数进行详细断言
        User capturedUser = userArgumentCaptor.getValue();
        // User(id=null, username=newUser, password=null, email=newUser@example.com, status=1, createTime=2025-08-20T19:35:55.725441800)
        System.out.println(capturedUser);
    }
}

// ... (imports and existing class structure) ...
import static org.assertj.core.api.Assertions.assertThatThrownBy;

// ... (within UserServiceImplTest class) ...

    @Test
    @DisplayName("保存用户失败路径：当用户名已存在时，应抛出业务异常")
    void testSaveUser_whenUserExists_shouldThrowException() {
        // --- GIVEN ---
        // 1. 准备输入数据
        UserEditDTO newUserDTO = new UserEditDTO();
        newUserDTO.setUsername("existingUser");
        
        // 2. 设定前置校验的行为：模拟用户已存在
        when(userMapper.selectOne(any())).thenReturn(new User());

        // --- WHEN & THEN ---
        // 3. 使用 AssertJ 的 assertThatThrownBy 来验证异常
        assertThatThrownBy(() -> {
            // 将会抛出异常的调用放在这里
            userService.saveUser(newUserDTO);
        })
        // 断言抛出的异常是 BusinessException 类型
        .isInstanceOf(BusinessException.class)
        // 并且，断言异常的消息与预期的错误码消息一致
        .hasMessage(ResultCode.UserAlreadyExists.getMessage());

        // 4. 【关键】防御性验证：确保在校验失败后，后续的交互从未发生
        verify(notificationService, never()).sendWelcomeEmailAsync(any());
        verify(userMapper, never()).insert(any(User.class));
    }

package com.example.demosystem;

import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.ComponentScan;

/**
 * 这个类是专门为 demo-system 模块的测试环境提供 Spring Boot 上下文。
 * 它本身可以是一个空壳，注解会完成所有工作。
 */
@SpringBootApplication
// 如果你的其他模块（如 demo-framework）的 Bean 也需要被扫描到，
// 可以加上 @ComponentScan 注解来扩大扫描范围。
// 假设你的所有模块包都以 com.example 开头
@ComponentScan("com.example")
@MapperScan("com.example.demosystem.mapper")
public class TestApplication {
}

package com.example.demosystem.controller;

import com.example.democommon.common.ResultCode;
import com.example.demosystem.service.UserService;
import com.example.demosystem.vo.UserVO;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import org.mockito.Mock;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.web.servlet.WebMvcTest;
import org.springframework.boot.test.mock.mockito.MockBean;
import org.springframework.cache.CacheManager;
import org.springframework.http.MediaType;
import org.springframework.test.web.servlet.MockMvc;

import static org.mockito.Mockito.when;
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.*;


// @WebMvcTest 会创建一个只包含 Web 层组件的、轻量级的 Spring 测试上下文。
// 由于我们创建了 TestApplication.java, 它会作为这个上下文的入口。
@WebMvcTest(controllers = UserController.class)
@DisplayName("用户控制器Web层测试")
class UserControllerTest {

    @Autowired
    private MockMvc mockMvc;

    // 我们只需要 Mock 掉 Controller 直接依赖的 Service 即可。
    // 如果测试启动时因为其他 @Configuration (如 CacheConfig) 而失败，
    // 才需要考虑使用 @ComponentScan.Filter 进行排除。
    @MockBean
    private UserService userService;

    @MockBean
    private CacheManager manager;

    @Test
    @DisplayName("GET /users/{id} - 当用户存在时，应返回成功和正确的用户信息")
    void testGetUserById_whenUserExists() throws Exception {
        // --- GIVEN ---
        UserVO mockUserVO = new UserVO();
        mockUserVO.setId(1L);
        // 根据 UserVO 的真实字段名，我们应该设置 name 属性
        mockUserVO.setName("testuser");

        when(userService.findUserById(1L)).thenReturn(mockUserVO);

        // --- WHEN & THEN ---
        mockMvc.perform(get("/users/1"))
                // 验证 HTTP 状态码为 200
                .andExpect(status().isOk())
                // 验证返回的 JSON 内容
                .andExpect(content().contentType(MediaType.APPLICATION_JSON))
                // 验证 JSON 内容的 code 属性
                .andExpect(jsonPath("$.code").value(200))
                // 验证 JSON 内容的 message 属性
                .andExpect(jsonPath("$.data.id").value(1L))
                // 验证 JSON 内容的 name 属性
                // 根据 @JsonProperty("user_name")，正确的 jsonPath 表达式应为 user_name
                .andExpect(jsonPath("$.data.user_name").value("testuser"));
    }

    @Test
    @DisplayName("GET /users/{id} - 当用户不存在时，应返回错误信息")
    void testGetUserById_whenUserNotExists() throws Exception {
        // --- GIVEN ---
        // 模拟 Service 层返回 null
        when(userService.findUserById(99L)).thenReturn(null);

        // --- WHEN & THEN ---
        // 根据 UserController 的真实逻辑，当用户不存在时，它会返回一个包含错误信息的 Result 对象
        mockMvc.perform(get("/users/99"))
                .andExpect(status().isOk()) // HTTP 状态码依然是 200
                .andExpect(jsonPath("$.code").value(ResultCode.ERROR.getCode())) // 业务码是错误码
                .andExpect(jsonPath("$.message").value("用户不存在")) // 验证错误信息
                .andExpect(jsonPath("$.data").isEmpty()); // data 字段应为空
    }
}

package com.example.demosystem.controller;
import com.example.demosystem.dto.user.UserEditDTO;
import com.example.demosystem.service.UserService;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.web.servlet.WebMvcTest;
import org.springframework.boot.test.mock.mockito.MockBean;
import org.springframework.cache.CacheManager;
import org.springframework.http.MediaType;
import org.springframework.test.web.servlet.MockMvc;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.when;
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.post;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.*;

/**
 * 用户控制器 Web 层测试
 */
@WebMvcTest(controllers = UserController.class)
@DisplayName("用户控制器Web层测试")
class UserControllerTest {

    @Autowired
    private MockMvc mockMvc;

    @MockBean
    private UserService userService;

    @MockBean
    private CacheManager cacheManager;
    
    @Autowired
    private ObjectMapper jacksonObjectMapper;
    
    @Test
    @DisplayName("POST /users - 使用合法的DTO应能成功创建用户")
    void testSaveUser_withValidDTO_shouldSucceed() throws Exception {
        // --- GIVEN ---
        // 1. 准备一个用于创建用户的 DTO 对象
        UserEditDTO newUserDTO = new UserEditDTO();
        newUserDTO.setUsername("newUser");
        newUserDTO.setEmail("newUser@example.com");
        newUserDTO.setPassword("password123");

        // 2. "打桩" Service 层：
        // 告诉 Mockito，当 userService.saveUser 方法被以任何 UserEditDTO 对象调用时，
        // 都应该返回一个虚构的新用户 ID，例如 100L。
        // 我们使用 any() 是因为 Service 层的详细逻辑已在单元测试中验证过，
        // 在这里我们只关心 Controller 和框架的集成。
        when(userService.saveUser(any(UserEditDTO.class))).thenReturn(100L);


        // --- WHEN & THEN ---
        mockMvc.perform(post("/users") // 1. 模拟一个 POST 请求
                        // 2. 【关键】设置请求头的 Content-Type 为 application/json
                        // 这告诉 Controller 我们发送的是 JSON 数据
                        .contentType(MediaType.APPLICATION_JSON)
                        // 3. 【关键】使用 objectMapper 将我们的 DTO 对象序列化为 JSON 字符串
                        // 并将其作为请求体发送
                        .content(jacksonObjectMapper.writeValueAsString(newUserDTO)))
                // 4. 对响应进行断言
                // 根据 UserController 的实现，成功创建应返回 HTTP 201 Created
                .andExpect(status().isCreated())
                // 验证我们自定义响应体中的业务码和数据
                .andExpect(jsonPath("$.code").value(200))
                .andExpect(jsonPath("$.data").value(100L));
    }
}

@Test
@DisplayName("POST /users - 当用户名已存在时，应返回用户已存在的错误")
@SneakyThrows
void testSaveUser_whenUsernameExists_shouldReturnBusinessError() {
    // --- GIVEN ---
    // 1. 准备一个合法的 DTO
    UserEditDTO userEditDTO = new UserEditDTO();
    userEditDTO.setUsername("TestUser");
    userEditDTO.setEmail("test@example.com");

    // 2. 【关键】"打桩" Service 层，让它在被调用时直接抛出我们预设的业务异常
    when(userService.saveUser(any(UserEditDTO.class))).thenThrow(new BusinessException(ResultCode.UserAlreadyExists));

    // --- WHEN & THEN ---
    mockMvc.perform(post("/users")
            .contentType(MediaType.APPLICATION_JSON)
            .content(jacksonObjectMapper.writeValueAsString(userEditDTO)))
            .andExpect(status().is4xxClientError())
            .andExpect(jsonPath("$.code").value(ResultCode.UserAlreadyExists.getCode()));
}

@Test
@DisplayName("POST /users - 当用户名已存在时，应返回用户已存在的错误")
@SneakyThrows
void testSaveUser_whenUsernameExists_shouldReturnBusinessError() {
    // --- GIVEN ---
    // 1. 准备一个合法的 DTO
    UserEditDTO userEditDTO = new UserEditDTO();
    userEditDTO.setUsername("TestUser");
    userEditDTO.setEmail("test@example.com");
    userEditDTO.setPassword("123456");

    // 2. 【关键】"打桩" Service 层，让它在被调用时直接抛出我们预设的业务异常
    when(userService.saveUser(any(UserEditDTO.class))).thenThrow(new BusinessException(ResultCode.UserAlreadyExists));

    // --- WHEN & THEN ---
    mockMvc.perform(post("/users")
            .contentType(MediaType.APPLICATION_JSON)
            .content(jacksonObjectMapper.writeValueAsString(userEditDTO)))
            .andExpect(jsonPath("$.code").value(ResultCode.UserAlreadyExists.getCode()));
}