package com.example.demo.service;

import com.example.demo.entity.User;
import com.example.demo.mapper.UserMapper;
import com.example.demo.service.impl.UserServiceImpl;
import com.example.demo.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.ArgumentMatchers.anyLong;
import static org.mockito.Mockito.when;

/**
 * @ExtendWith(MockitoExtension.class): 启用 Mockito 注解支持
 * 注意：这里没有用 @SpringBootTest，因为我们不需要启动 Spring 容器
 */
@ExtendWith(MockitoExtension.class)
class UserServiceTest {

    // @Mock: 创建一个模拟对象 (假的 Mapper)
    @Mock
    private UserMapper userMapper;

    // @InjectMocks: 创建被测试对象 (Service)，并自动把上面的 @Mock 注入进去
    @InjectMocks
    private UserServiceImpl userService;

    @Test
    @DisplayName("测试根据ID查询用户 - 正常场景")
    void testGetUserById_Success() {
        // 1. Given (准备数据与行为)
        User mockUser = new User();
        mockUser.setId(1L);
        mockUser.setUsername("test_user");
        mockUser.setStatus(1);

        // 告诉 Mockito：当有人调用 userMapper.selectById(1L) 时，请返回 mockUser
        // 这里的 anyLong() 是参数匹配器
        when(userMapper.selectById(1L)).thenReturn(mockUser);

        // 2. When (执行被测方法)
        UserVO result = userService.getUserById(1L);

        // 3. Then (断言结果)
        // 使用 AssertJ 风格断言
        assertThat(result).isNotNull();
        assertThat(result.getId()).isEqualTo(1L);
        assertThat(result.getStatusText()).isEqualTo("正常");
    }

    @Test
    @DisplayName("测试根据ID查询用户 - 用户不存在")
    void testGetUserById_NotFound() {
        // 1. Given
        when(userMapper.selectById(anyLong())).thenReturn(null);

        // 2. When
        UserVO result = userService.getUserById(999L);

        // 3. Then
        assertThat(result).isNull();
    }
}

package com.example.demo.controller;

import com.example.demo.service.UserService;
import com.example.demo.vo.UserVO;
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.http.MediaType;
import org.springframework.test.web.servlet.MockMvc;

import static org.mockito.BDDMockito.given;
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.jsonPath;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;

/**
 * @WebMvcTest: 只实例化 Web 层相关的 Bean (Controller, ExceptionHandler 等)
 */
@WebMvcTest(UserController.class)
class UserControllerTest {

    @Autowired
    private MockMvc mockMvc; // 模拟 HTTP 请求的核心工具

    @MockBean // 将 Service 模拟掉，放入 Spring 容器，替换真实的 Service
    private UserService userService;

    @Test
    @DisplayName("GET /users/{id} - 应该返回 200 和 JSON 数据")
    void testGetUser_ShouldReturnUser() throws Exception {
        // 1. 准备数据
        UserVO mockVO = new UserVO();
        mockVO.setId(100L);
        mockVO.setUsername("mock_controller");

        // 模拟 Service 行为
        given(userService.getUserById(100L)).willReturn(mockVO);

        // 2. 发起请求并验证
        mockMvc.perform(get("/users/100") // 发起 GET 请求
                .contentType(MediaType.APPLICATION_JSON))
                // 3. 验证 HTTP 状态码是否为 200
                .andExpect(status().isOk())
                // 4. 验证返回的 JSON 内容 (jsonPath 语法)
                .andExpect(jsonPath("$.code").value(200)) // 验证 Result 包装
                .andExpect(jsonPath("$.data.id").value(100))
                .andExpect(jsonPath("$.data.user_name").value("mock_controller")); // 验证 Jackson 注解生效
    }
}

// JUnit 5 原生
assertEquals(expected, actual); 
// 容易搞混哪个是期望值，哪个是实际值

// AssertJ
assertThat(actual).isEqualTo(expected); 
// 读起来像英语句子：断言(实际值).等于(期望值)

// 字符串
assertThat(name).startsWith("test").endsWith("user").hasSize(9);

// 集合
assertThat(userList)
    .hasSize(3)
    .contains(userA)
    .doesNotContain(userB)
    .extracting("username") // 提取所有对象的 username 属性
    .contains("zhangsan", "lisi");

// 异常
assertThatThrownBy(() -> service.errorMethod())
    .isInstanceOf(BusinessException.class)
    .hasMessage("余额不足");

@InjectMocks OrderService service;
@Mock UserMapper mapper;

@Test
void test() {
    when(mapper.selectById(1L)).thenReturn(vipUser);
    service.calculate(1L);
    verify(mapper).updateScore(any()); // 验证是否调用了更新方法
}

mockMvc.perform(post("/users")
        .content("{\"age\": -1}") // 发送非法数据
        .contentType(MediaType.APPLICATION_JSON))
        .andExpect(status().isOk()) // 即使业务失败，HTTP 状态码也可能是 200
        .andExpect(jsonPath("$.code").value(400)); // 验证业务状态码为 400

@SpringBootTest
class MapperTest {
    @Autowired UserMapper mapper;
    @Test
    void testSql() {
        User user = mapper.selectOne(new QueryWrapper<User>().eq("name", "tom"));
        assertThat(user).isNotNull();
    }
}