Back to Repositories

Testing MyBatis-Plus Database Operations in spring-boot-examples

This test suite demonstrates comprehensive unit testing of MyBatis-Plus functionality within a Spring Boot application. It covers essential database operations including CRUD operations, pagination, and conditional queries using MyBatis-Plus’s enhanced features.

Test Coverage Overview

The test suite provides thorough coverage of MyBatis-Plus core functionalities.

Key areas tested include:

Basic CRUD operations (insert, update, delete, select)
Conditional queries using QueryWrapper
Pagination functionality
Dynamic SQL generation
Entity ID management

Integration points cover the interaction between MyBatis-Plus mapper interfaces and Spring Boot’s database layer.

Implementation Analysis

The testing approach utilizes Spring Boot’s test framework integrated with JUnit 4. Tests leverage MyBatis-Plus’s fluent API for database operations, employing lambda expressions for type-safe queries and updates.

Notable patterns include:

Autowired dependency injection for mapper interfaces
Assertion-based result verification
Lambda-based query construction
Pagination implementation using Page objects

Technical Details

Testing tools and configuration:

JUnit 4 with SpringRunner
Spring Boot Test context
MyBatis-Plus core and extension libraries
AssertJ for fluent assertions
QueryWrapper for dynamic SQL conditions
Page and IPage interfaces for pagination

Best Practices Demonstrated

The test suite exemplifies high-quality testing practices in the MyBatis-Plus ecosystem.

Notable practices include:

Isolated test methods for specific functionality
Comprehensive assertion coverage
Clear test method naming
Proper test setup and configuration
Efficient use of MyBatis-Plus features
Structured error handling and validation

ityouknow/spring-boot-examples

2.x/spring-boot-mybatis-plus/src/test/java/com/neo/MyBatisPlusTest.java

            
package com.neo;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.core.toolkit.CollectionUtils;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.neo.mapper.UserMapper;
import com.neo.model.User;
import org.junit.Assert;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

import java.util.List;

import static org.assertj.core.api.Assertions.assertThat;

@RunWith(SpringRunner.class)
@SpringBootTest
public class MyBatisPlusTest {

    @Autowired
    private UserMapper userMapper;


    @Test
    public void testSelectOne() {
        User user = userMapper.selectById(1L);
        System.out.println(user);
    }

    @Test
    public void testInsert() {
        User user = new User();
        user.setName("微笑");
        user.setAge(3);
        user.setEmail("[email protected]");
        assertThat(userMapper.insert(user)).isGreaterThan(0);
        // 成功直接拿会写的 ID
        assertThat(user.getId()).isNotNull();
    }

    @Test
    public void testDelete() {
        assertThat(userMapper.deleteById(3L)).isGreaterThan(0);
        assertThat(userMapper.delete(new QueryWrapper<User>()
                .lambda().eq(User::getName, "smile"))).isGreaterThan(0);
    }

    @Test
    public void testUpdate() {
        User user = userMapper.selectById(2);
        assertThat(user.getAge()).isEqualTo(36);
        assertThat(user.getName()).isEqualTo("keep");

        userMapper.update(
                null,
                Wrappers.<User>lambdaUpdate().set(User::getEmail, "123@123").eq(User::getId, 2)
        );
        assertThat(userMapper.selectById(2).getEmail()).isEqualTo("123@123");
    }

    @Test
    public void testSelect() {
        List<User> userList = userMapper.selectList(null);
        Assert.assertEquals(5, userList.size());
        userList.forEach(System.out::println);
    }

    @Test
    public void testSelectCondition() {
        QueryWrapper<User> wrapper = new QueryWrapper<>();
        wrapper.select("max(id) as id");
        List<User> userList = userMapper.selectList(wrapper);
        userList.forEach(System.out::println);
    }

    @Test
    public void testPage() {
        System.out.println("----- baseMapper 自带分页 ------");
        Page<User> page = new Page<>(1, 2);
        IPage<User> userIPage = userMapper.selectPage(page, new QueryWrapper<User>()
                .gt("age", 6));
        assertThat(page).isSameAs(userIPage);
        System.out.println("总条数 ------> " + userIPage.getTotal());
        System.out.println("当前页数 ------> " + userIPage.getCurrent());
        System.out.println("当前每页显示数 ------> " + userIPage.getSize());
        print(userIPage.getRecords());
        System.out.println("----- baseMapper 自带分页 ------");
    }

    private <T> void print(List<T> list) {
        if (!CollectionUtils.isEmpty(list)) {
            list.forEach(System.out::println);
        }
    }


}